alternativesAsExact

Alternatives of query words that should be considered exact matches.

The alternativesAsExact parameter defines which types of query word alternatives should be treated as exact matches by the Exact ranking criterion. By default, plural forms (with ignorePlurals) and single-word synonyms are considered exact. You can extend or limit this behavior based on your use case.

For more information, see:

• Adjust the Exact criterion
• Customize plurals and other declensions

Options

ignorePlurals

Treats plural and inflected forms (enabled by ignorePlurals) as exact matches.

singleWordSynonym

Treats single-word synonyms (for example, "NY" = "NYC") as exact matches.

multiWordsSynonym

Treats multi-word synonyms (for example, "NY" = "New York") as exact matches.

Examples

Current API clients

C#

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings
  {
    AlternativesAsExact = new List<AlternativesAsExact>
    {
      Enum.Parse<AlternativesAsExact>("IgnorePlurals"),
      Enum.Parse<AlternativesAsExact>("SingleWordSynonym"),
    },
  }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    alternativesAsExact: [
      AlternativesAsExact.fromJson("ignorePlurals"),
      AlternativesAsExact.fromJson("singleWordSynonym"),
    ],
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetAlternativesAsExact(
    []search.AlternativesAsExact{search.AlternativesAsExact("ignorePlurals"), search.AlternativesAsExact("singleWordSynonym")})))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setAlternativesAsExact(Arrays.asList(AlternativesAsExact.IGNORE_PLURALS, AlternativesAsExact.SINGLE_WORD_SYNONYM))
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: { alternativesAsExact: ['ignorePlurals', 'singleWordSynonym'] },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings =
      IndexSettings(
        alternativesAsExact =
          listOf(
            AlternativesAsExact.entries.first { it.value == "ignorePlurals" },
            AlternativesAsExact.entries.first { it.value == "singleWordSynonym" },
          )
      ),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['alternativesAsExact' => [
        'ignorePlurals',

        'singleWordSynonym',
    ],
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "alternativesAsExact": [
            "ignorePlurals",
            "singleWordSynonym",
        ],
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(alternatives_as_exact: ["ignorePlurals", "singleWordSynonym"])
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      alternativesAsExact =
        Some(Seq(AlternativesAsExact.withName("ignorePlurals"), AlternativesAsExact.withName("singleWordSynonym")))
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(alternativesAsExact: [
        SearchAlternativesAsExact.ignorePlurals,
        SearchAlternativesAsExact.singleWordSynonym,
    ])
)

Legacy API clients

C#

IndexSettings settings = new IndexSettings();
settings.AlternativesAsExact = new List
{
    "ignorePlurals",
    "singleWordSynonym",
    "multiWordsSynonym",
};

index.SetSettings(settings);

res, err := index.SetSettings(search.Settings{
	AlternativesAsExact: opt.AlternativesAsExact(
		"ignorePlurals",
		"singleWordSynonym",
		"multiWordsSynonym",
	),
})

index.setSettings(
  new IndexSettings().setAlternativesAsExact(Arrays.asList(
    "ignorePlurals",
    "singleWordSynonym",
    "multiWordsSynonym"
  ))
);

index
  .setSettings({
    alternativesAsExact: [
      "ignorePlurals",
      "singleWordSynonym",
      "multiWordsSynonym",
    ],
  })
  .then(() => {
    // done
  });

val settings = settings {
  alternativesAsExact {
    +IgnorePlurals
    +SingleWordSynonym
    +MultiWordsSynonym
  }
}

index.setSettings(settings)

$index->setSettings([
  'alternativesAsExact' => [
    'ignorePlurals',
    'singleWordSynonym',
    'multiWordsSynonym'
  ]
]);

index.set_settings(
    {"alternativesAsExact": ["ignorePlurals", "singleWordSynonym", "multiWordsSynonym"]}
)

index.set_settings(
  {
    alternativesAsExact: [
      "ignorePlurals",
      "singleWordSynonym",
      "multiWordsSynonym"
    ]
  }
)

client.execute {
  setSettings of "myIndex" `with` IndexSettings(
    alternativesAsExact = Some(Seq(
      "ignorePlurals",
      "singleWordSynonym",
      "multiWordsSynonym"
    ))
  )
}

let settings = Settings()
  .set(\.alternativesAsExact, to: [.ignorePlurals, .singleWordSynonym, .multiWordsSynonym])

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