View source for First-class citizen (programming)

{{#addbodyclass:tag_tech}}
{{#addbodyclass:tag_prog}}
{{programming}}


{{comment|(it is potentially confusing that the 'class' in first-class here refers not to OO classes but the sense of quality - first-rate, second-rate, etc.)}}


First-class citizen tends to refer to a language in which a particular ''thing'' is like any other - and ''without'' any trickery.


For example, in Javascript and Python, functions are first-class objects:
They are part of the language's typing system, you can construct them, you can return them, you can hand them around and assign them to variables.

Contrast this with C++, where functions themselves are not first class objects - after compilation, 
they do not exist as things you can hand around and inspect, 
only really as "if you put the right things on the stack and jump here, things will happen as expected".
(...with footnotes, I know.)


<!--
: (Languages that say "everything is an object" often mean "all objects are first-class")
-->


Raphael Finkel splits this particular case out out a bit more:
* first-class - An entity you can pass as a parameter, return, and assign to a variable
* second-class - an entity you can passed as a parameter, cannot returned from a function, and cannot store into a variable
* third-class - an enitity you cannot pass as a parameter, cannot returned from a function, and cannot store into a variable
(TODO: examples)


<!--

The most common indications / things we care about are the ability to pass as an argument, returned from a function, and assigned to a variable.


For example, in python, functions as objects is considered



'''First-class objects''' often refers to dynamic languages, constructing objects at runtime, 
refers to objects that you create at runtime that you can do that (and more).


A '''First-class type''' refers to a language


In programming, '''First-class citizen''' has varied definitions, because the most useful distinction depends on context.

For example, you can give a more useful definition when describing to a specific static language (e.g. C++),
or a specific dynamic language (e.g. JS, Python),
or a language that cheats usefully (e.g Java).


-->



<!--
'''First-class type''' is sometimes meant to use first-class object, but if used more precisely means the ability to define a ''class'' at runtime.

This can be used to point out (possibly clarify, possibly confuse) that e.g. in C++, objects are are first-class objects, but classes are not.
-->


<!--
Somewhere else on this wiki we call text to be a first-class citizen in the the DOM view of XML, there meaning a text node is a specific object that has to come under an element node.

...there compared to ElementTree, which makes only element a first-rate citizen, text specifically not and sticks text on the nearest element object

Say, DOM would see 
 <xml> <a> </a> </xml>
as something like:
 element:xml
   text:' '
   element:a
     text:' '
   text:' '
whereas ET would see it something like:
 element:xml {text:' ', tail:None}
   element:a {text:' ', tail:' '}





You could extend the first-class citizen idea to data formats (which here is fuzzier with the concept of native types)

For example
: [[JSON]] does not say anything about a date format, so it's up to you to decide to save a ISO8601 string, unix time int/float, or similar. It will not become a Date object, though
: [[TOML]] specifies date, time, and timezone (largely following ISO8601) (though doesn't specify it as an unambiguous type)
: [[YAML]] also seems to mention these -- but also doesn't specify it as a type
...so that's not the best example





-->


https://en.wikipedia.org/wiki/First-class_citizen