alternativesAsExact

1
2
3
4
5
6
index.set_settings({
  alternativesAsExact: [
    'ignorePlurals',
    'singleWordSynonym'
  ]
})

1
2
3
4
5
6
7
8
index.setSettings({
  alternativesAsExact: [
    'ignorePlurals',
    'singleWordSynonym'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
6
index.set_settings({
    'alternativesAsExact': [
        'ignorePlurals',
        'singleWordSynonym'
    ]
})

1
2
3
4
5
6
7
8
let settings = Settings()
  .set(\.alternativesAsExact, to: [.ignorePlurals, .singleWordSynonym])

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 {
    alternativesAsExact {
        +IgnorePlurals
        +SingleWordSynonym
    }
}

index.setSettings(settings)

1
2
3
4
5
6
7
8
IndexSettings settings = new IndexSettings();
settings.AlternativesAsExact = new List<string>
{
    "ignorePlurals",
    "singleWordSynonym"
};

index.SetSettings(settings);

1
2
3
4
5
6
index.setSettings(
  new IndexSettings().setAlternativesAsExact(Arrays.asList(
    "ignorePlurals",
    "singleWordSynonym"
  ))
);

1
2
3
4
5
6
res, err := index.SetSettings(search.Settings{
  AlternativesAsExact: opt.AlternativesAsExact(
    "ignorePlurals",
    "singleWordSynonym",
  ),
})

1
2
3
4
5
6
7
8
client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    alternativesAsExact = Some(Seq(
      "ignorePlurals",
      "singleWordSynonym"
    ))
  )
}

1
2
3
results = index.search('query', {
  alternativesAsExact: ['multiWordsSynonym']
})

1
2
3
4
5
index.search('query', {
  alternativesAsExact: ['multiWordsSynonym']
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
results = index.search('query', {
    'alternativesAsExact': ['multiWordsSynonym']
})

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

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

1
2
3
4
5
6
7
val query = query("query") {
    alternativesAsExact {
        +MultiWordsSynonym
    }
}

index.search(query)

1
2
3
4
5
6
7
index.Search<T>(new Query("")
{
    AlternativesAsExact = new List<string>
    {
      "multiWordsSynonym"
    },
});

1
2
3
4
5
6
7
8
index.search(
  new Query("query")
    .setAlternativesAsExact(
      Collections.singletonList(
        "multiWordsSynonym"
      )
    )
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.AlternativesAsExact("multiWordsSynonym"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    alternativesAsExact = Some(Seq("multiWordsSynonym"))
  )
}