1
2
3
4
5
6
index.set_settings({
  optionalWords: [
    'blue',
    'iphone case'
  ]
})

1
2
3
4
5
6
7
8
index.setSettings({
  optionalWords: [
    'blue',
    'iphone case'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
6
index.set_settings({
    'optionalWords': [
        'blue',
        'iphone case'
    ]
})

1
2
3
4
5
6
7
8
let settings = Settings()
  .set(\.optionalWords, to: ["blue", "iphone case"])

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val settings = settings {
    optionalWords {
        +"blue"
        +"iphone case"
    }
}

index.setSettings(settings)

1
2
3
4
5
6
7
8
IndexSettings settings = new IndexSettings();
settings.OptionalWords = new List<string>
{
  "blue",
  "iphone case"
},

index.SetSettings(settings);

1
2
3
4
5
6
7
8
9
index.setSettings(
  new IndexSettings()
    .setOptionalWords(
      Arrays.asList(
        "blue",
        "iphone case"
      )
    )
);

1
2
3
4
5
6
res, err := index.SetSettings(search.Settings{
  OptionalWords: opt.OptionalWords(
    "blue",
    "iphone case",
  ),
})

1
2
3
4
5
6
7
8
client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    optionalWords = Some(Seq(
      "blue",
      "iphone case"
    ))
  )
}

1
2
3
4
5
6
results = index.search('query', {
  optionalWords: [
    'toyota',
    '2020 2021'
  ]
})

1
2
3
4
5
6
7
8
index.search('query', {
  optionalWords: [
    'toyota',
    '2020 2021'
  ]
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
results = index.search('query', {
    'optionalWords': [
        'toyota',
        '2020 2021'
    ]
})

1
2
3
4
5
6
let query = Query(query: "query")
query.optionalWords = ["toyota", "2020 2021"]

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
5
6
7
8
val query = query("query") {
    optionalWords {
        +"toyota"
        +"2020 2021"
    }
}

index.search(query)

1
2
3
4
5
6
7
8
index.Search<T>(new Query("")
{
    OptionalWords = new List<string>
    {
      "toyota",
      "2020 2021"
    },
});

1
2
3
4
5
6
7
8
9
index.search(
  new Query("query")
    .setOptionalWords(
      Arrays.asList(
        "toyota",
        "2020 2021"
      )
    )
);

1
2
3
4
5
6
7
8
res, err := index.Search(
"query",

  OptionalWords: opt.OptionalWords(
    "toyota",
    "2020 2021",
  },
})

1
2
3
4
5
6
7
8
9
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    optionalWords = Some(Seq(
      "toyota",
      "2020 2021"
    ))
  )
}

1
2
3
4
5
6
7
query = 'the query'

params = {
  optionalWords: query
}

results = index.search(query, params)

1
2
3
4
5
6
7
8
9
const query = 'the query';

const params = {
  'optionalWords': query
};

index.search(query, params).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
7
query = 'the query'

params = {
    'optionalWords': query
}

results = index.search(query, params)

1
2
3
4
5
6
7
8
9
let queryString = "query"
let query = Query(queryString)
  .set(\.optionalWords, to: [queryString])

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
val queryString = "query"
val query = query(queryString) {
    optionalWords {
        +queryString
    }
}

index.search(query)

1
2
3
4
5
6
String query = "the query";

index.Search<T>(new Query(query)
{
    OptionalWords = new List<string> { query };
});

1
2
3
4
5
6
7
8
9
10
String query = "the query";

index.search(
  new Query(query)
    .setOptionalWords(
      Collections.singletonList(
        query
      )
    )
);

1
2
3
4
5
6
query := "the query"

res, err := index.Search(
  query,
  opt.OptionalWords(query),
)

1
2
3
4
5
6
7
8
9
10
val query = "the query"

client.execute {
  search into "myIndex" query Query(
    query = Some(query),
    optionalWords = Some(Seq(
      query
    ))
  )
}