F-list Search Reference

From F-List Wiki
Jump to: navigation, search

Welcome. The search function is actually quite robust on F-list, in case you didn't know. The automagical filler on the left-hand side when you go to the search page will do you fine if you are a beginner or don't want to bother with technical things.

However, if you came here for the more intricate things you can make that search function do, hit the 'Show advanced' tick box and we'll see what kind of fun we can have. It will help if you have some fundamental understanding of logical operations such as AND, NAND, OR and the like.

As fields represented by dropdown lists use numbers, instead of text, for searching, it's helpful to have a list of which numbers to use. Here are the lists of field names, field values (sorted by fields), and kink values (alphabetical).

Searching Syntax

By default, search fields will use the syntax of

(field_name: field_paramaters)

Logic can be applied to field_paramaters but NOT field_names. Also, one can drop the field_name and simply have a field_paramter, such as

(kitty)

Which is known as a wide-search and will search all text-fields that are not the description. Reliability is not tested/known.

Logical Syntax

Here as some examples of search syntax being used with logical operators.

Incorrect: (age: 5 OR 6)
Incorrect: (age: 5 || 6)
Incorrect: ((age || apparent_age): 6)
Correct: (age: (5 OR 6))
Correct: (age: (5 || 6))
AND, &&

These are all identical to the search. Returns anyone who has both 'jane' and 'lane' anywhere in their name. Special characters are ignored.

(name: Jane) (name: lane)
(name: Jane) && (name: Lane)
(name: Jane) AND (name: Lane)

Placing elements next to each other without any logical operator assumes AND by default. A character must satisfy all joined AND statements for it to be returned.

NOT, !

The NOT Logical operator will return search fields that are the opposite of what is inside. These are identical and return any characters who do not have 'penis' in their description. (Which is a lot)

NOT (description: penis)
!(description: penis)

It can be placed almost anywhere inside or outside of a search field.

!(name: Kitty)
(name: !(kitty))
(name: !((Kitty) || (cat)))
(name: (!(kitty) || (cat)))

A character must NOT satisfy a statement in order for it to be returned.

OR, ||

A counter-part to AND, returns anyone who satisfies EITHER (or both) of the search parameters.

(age: 6) || (age:5)
(age:5) OR (age:6)

Identical, returns any profile whose age is either 5 or 6.

Wildcard, *

The wild card is very useful for searching for various reasons. When used in a search parameter, it tells the search to assume the parameter is abstract, and not a definite term. It searches for things that are based on or related to that depending on where you place the wild card. No search parameter BUT a wild-card tells the search to REQUIRE this field to be present (filled-out).

(custom_fetish: *)
(email: *)

A character mus have a custom fetish or an email filled out to return. This can also be used to determine if the character has a kink filled-out:

(kink: *|77)

Returns all characters who have 3+ penetration in ANY list.

(email: mistress_*)

Returns all characters who have an email defined that starts with "mistress_"

(email: *mistress)

Returns all characters who have an email that ends with "mistress"

(email: *mistress*)

Returns all characters who have an email with "mistress" somewhere in it.

Single Wildcard, ?

This wildcard is a restricted version of the asterisk. The wildcard allows 0 to infinite amount of characters where you place it, while the single wildcard only allows a single character there.

(cock_length: ?)

This allows you to find characters who have a cock that is in the single digits (i.e, not hyper). Note however that this is not perfect, and we can do better.

(cock_length: ?) || (cock_length: ?.*)

This is what we want. This finds any single-digit cocklengths with any number of numbers in the decimal point afterwards, while still excluding people who are ten inches and above.

The 'kink' field

(fetish: yes|77)
((fetish: (yes\|77)))

Both of these are the 'correct' way to do it. The former is the way a human would do it, and the latter is the way the auto-filler does it. The entire thing after 'fetish:' is treated as a single search parameter, not two. Do not break them up, at all. Some things which will not work:

(fetish: (yes)|77)
(fetish: yes|(77))
(fetish: ( (yes|77 OR favorite|77) ))
(fetish: ( (yes|77 OR !favorite|77) ))
(fetish: (yes OR favorite)|77)

You might be thinking 'how do I search for multiple fetishes or the same fetish in multiple lists?', and well, here's how.

(fetish: ((yes|77) || (fave|77) || (maybe|77)) )

This is the only correct way to do this.

Text fields

Almost all text fields behave the same way. In a text field, parts of the field separated by a space are considered different parameters (as far as searching is concerned).

(species: (ocelot || cat))

Will return any character who has 'ocelot' or 'cat' as their species, obviously. But what if our character's species tag was more complex?

Cat - Ocelot
Cat ( Ocelot )
Cat Ocelot
etc.

Will all return for that above search. You can applies this to maximize the search results you return on for text fields. So long as there is a space between the fields, someone could search for only one of them (or both of them) and you will be returned on that search!

Advanced Examples

The search is robust. Thus, advanced and oddly-specific searches are not only possible, but can be quite rewarding if done right.

Shota Doms

(gender: 1) (age: (12 || 13 || 14 || 15)) AND (

((domsub_role: (10 || 11)) (fetish: (fave|137 || yes|137)) )

OR

(!(domsub_role: (10 || 11)) (fetish: (fave|157 || yes|157)) )

) Searches for shotas between 12-15. If they are dominant, they must have 'Anal Sex(Giving)' in 'Yes' or 'Favorite', and if sub, they must have the opposite in the same lists.

Underage

For under-aged characters (or people who wish to avoid them), there are a few ways to find these search only for these characters.

Method 1, using operators you're familiar with. This is mostly predictable, but it includes some outliers.

(age: (? || 1?) ) -(age: (18 || 19))

We can perfect this with more advanced logic, however.

((age: [0 TO 9])(age:?))
||
((age: [0 TO 17])(age:??))

This will perform as expected and not include many if any outliers, although it is unwieldy.


To exclude them, you'll have to negate the earlier logic. There's not much simplifying that can be done with method one, but boolean algebra lets us do a neat trick with method 2, turning it into something fairly compact.

-(((age: (? || 1?) ) -(age: (18 || 19)))

Or

(age: [17 TO 9])(age:??)

Age Ranges

Similar to underage, there are a few ways to search for any arbitrary age bracket.

Let's say we want to find people between 20 and 40 inclusive. Method 1, using simple OR gates with the age field:

(age: (2? || 3? || 40))

Method 2, using the TO operator:

(age: [20 TO 40])(age:??)

Now let's get more specific. We want the range [19, 45]. Method 1:

(age (19 || 2? || 3? || 4?)) -(age: (46 || 47 || 48 || 49))

Method 2:

(age: [19 TO 45])(age: ??)

Huzzah! Look how much nicer that is. While it is up to you which to use, the TO field provides an easier way of searching arbitrary. Note, however, that the (age:??) is very important.