<commit_before>
         
   TYPES  
         



BY LANGUAGE ==>                   #  +-----------------------------+------------+----------+----------+-------------+
                                  #  |           LANGAGE           |  CHECKING  | EXPLICIT |  SAFETY  | DEFINITION  |
                                  #  +-----------------------------+------------+----------+----------+-------------+
                                  #  |            ASM x86          |    none    |  strong  |  unsafe  |  structural |
                                  #  |             PHP             |  dynamic   |   weak   |   safe   |   none      |
                                  #  |           JavaScript        |  dynamic   |   weak   |   safe   |   duck      |
                                  #  |            Python           |  dynamic   |  strong  |   safe   |   duck      |
                                  #  |             Ruby            |  dynamic   |  strong  |   safe   |   duck      |
                                  #  |             Perl            |  dynamic   |   weak   |   safe   |  nominative |
                                  #  |              C              |   static   |   weak   |  unsafe  |  nominative |
                                  #  |             BASIC           |   static   |   weak   |   safe   |  nominative |
                                  #  |             C++             |   static   |  strong  |  unsafe  |  nominative |
                                  #  |              C#             |   static   |  strong  |  middle  |  nominative |
                                  #  |             Java            |   static   |  strong  |   safe   |  nominative |
                                  #  |            FORTRAN          |   static   |  strong  |   safe   |  nominative |
                                  #  |            Pascal           |   static   |  strong  |   safe   |  nominative |
                                  #  +-----------------------------+------------+----------+----------+-------------+


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:          DEFINITION           :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/


TYPE ==>                          #A type is a name associated with a data structure.
                                  #Type identity is linked to the:
                                  #  - structure:
                                  #     - e.g. two names pointing to same structure are same type
                                  #     - type checking can be:
                                  #        - static, i.e. compile-time ("structural")
                                  #        - dynamic, i.e. run-time ("duck typing"): similar to generic programming "concepts"
                                  #     - structure can be thought as:
                                  #        - the binary representation
                                  #        - the behavior:
                                  #           - i.e. associated algorithms/operators/methods, their constraint and their complexity
                                  #           - state can either be manipulated imperatively (mutated) or functionally (i.e. returned as copy)
                                  #        - the value space, i.e. set of possible values
                                  #  - name ("nominative"):
                                  #     - e.g. two names pointing to same structure are different types

DEFINITION ==>                    #During variable definition, type must be:
                                  #  - explicit: "manifest typing"
                                  #  - implicit and decided:
                                  #     - compile-time: "implicit typing" / "type inference"
                                  #     - runtime: "latent typing"

ABSTRACT DATA TYPE (ADT) ==>      #Data type without implementation specifics
                                  #E.g. integers vs 32-bit binary numbers

PROBABLISTIC DATA TYPE ==>        #Data type that uses randomness.
                                  #This includes data types whose operations give an approximate result, e.g. Bloom filters.

PERSISTENT DATA TYPE ==>          #See state doc

OPERATIONS ==>                    #Most common operations on types:
                                  #  - create/insert
                                  #  - read:
                                  #     - by key: access
                                  #     - by value: search
                                  #  - update
                                  #  - delete


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:          COMPOSITION          :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/


SIMPLE VS COMPOSITE ==>           #Composite|compound|aggregate types are composed of other types, as opposed to simple|primitive types.
                                  #Data structures are composite types associated with specific algorithms/operations.

UNION TYPE ==>                    #Type which can be any of several given types.
                                  #Also called "sum type".
                                  #At runtime, the current type can either be:
                                  #  - tagged, i.e. recorded:
                                  #     - allows for better type checking
                                  #  - untagged:
                                  #     - takes less space
                                  #"Top" type / "variant" is union of all possible types:
                                  #  - often called "any" or just "object" (when all types derive from base type "object")

INTERSECTION TYPE ==>             #Type which combines constraints and behavior of several given types.
                                  #Is conceptually similar to multiple inheritance.

DEPENDENT TYPE ==>                #Composite type where one of its member's type has a constraint based on another member's type.
                                  #Examples:
                                  #  - [NUM, NUM2], where NUM2 > NUM
                                  #  - FUNC(NUM)->ARR, where ARR.length === NUM


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:            SAFETY             :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/

<commit_msg>no commit message<commit_after>
         
   TYPES  
         



BY LANGUAGE ==>                   #  +-----------------------------+------------+----------+----------+-------------+
                                  #  |           LANGAGE           |  CHECKING  | EXPLICIT |  SAFETY  | DEFINITION  |
                                  #  +-----------------------------+------------+----------+----------+-------------+
                                  #  |            ASM x86          |    none    |  strong  |  unsafe  |  structural |
                                  #  |             PHP             |  dynamic   |   weak   |   safe   |   none      |
                                  #  |           JavaScript        |  dynamic   |   weak   |   safe   |   duck      |
                                  #  |            Python           |  dynamic   |  strong  |   safe   |   duck      |
                                  #  |             Ruby            |  dynamic   |  strong  |   safe   |   duck      |
                                  #  |             Perl            |  dynamic   |   weak   |   safe   |  nominative |
                                  #  |              C              |   static   |   weak   |  unsafe  |  nominative |
                                  #  |             BASIC           |   static   |   weak   |   safe   |  nominative |
                                  #  |             C++             |   static   |  strong  |  unsafe  |  nominative |
                                  #  |              C#             |   static   |  strong  |  middle  |  nominative |
                                  #  |             Java            |   static   |  strong  |   safe   |  nominative |
                                  #  |            FORTRAN          |   static   |  strong  |   safe   |  nominative |
                                  #  |            Pascal           |   static   |  strong  |   safe   |  nominative |
                                  #  +-----------------------------+------------+----------+----------+-------------+


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:          DEFINITION           :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/


TYPE ==>                          #A type is a name associated with a data structure.
                                  #Type identity is linked to the:
                                  #  - structure:
                                  #     - e.g. two names pointing to same structure are same type
                                  #     - type checking can be:
                                  #        - static, i.e. compile-time ("structural")
                                  #        - dynamic, i.e. run-time ("duck typing"): similar to generic programming "concepts"
                                  #     - structure can be thought as:
                                  #        - the binary representation
                                  #        - the behavior:
                                  #           - i.e. associated algorithms/operators/methods, their constraint and their complexity
                                  #           - state can either be manipulated imperatively (mutated) or functionally (i.e. returned as copy)
                                  #        - the value space, i.e. set of possible values
                                  #  - name ("nominative"):
                                  #     - e.g. two names pointing to same structure are different types

DEFINITION ==>                    #During variable definition, type must be:
                                  #  - explicit: "manifest typing"
                                  #  - implicit and decided:
                                  #     - compile-time: "implicit typing" / "type inference"
                                  #     - runtime: "latent typing"

ABSTRACT DATA TYPE (ADT) ==>      #Data type without implementation specifics
                                  #E.g. integers vs 32-bit binary numbers

PROBABLISTIC DATA TYPE ==>        #Data type that uses randomness.
                                  #This includes data types whose operations give an approximate result, e.g. Bloom filters.

PERSISTENT DATA TYPE ==>          #See state doc

OPERATIONS ==>                    #Most common operations on types:
                                  #  - create/insert
                                  #  - read:
                                  #     - by key: access
                                  #     - by value: search
                                  #  - update
                                  #  - delete


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:          COMPOSITION          :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/


SIMPLE VS COMPOSITE ==>           #Composite|compound|aggregate types are composed of other types, as opposed to simple|primitive types.
                                  #Data structures are composite types associated with specific algorithms/operations.

UNION TYPE ==>                    #Type which can be any of several given types.
                                  #Also called "sum type".
                                  #At runtime, the current type can either be:
                                  #  - tagged, i.e. recorded:
                                  #     - allows for better type checking
                                  #     - also called "discriminated union"
                                  #  - untagged:
                                  #     - takes less space
                                  #"Top" type / "variant" is union of all possible types:
                                  #  - often called "any" or just "object" (when all types derive from base type "object")

INTERSECTION TYPE ==>             #Type which combines constraints and behavior of several given types.
                                  #Is conceptually similar to multiple inheritance.

DEPENDENT TYPE ==>                #Composite type where one of its member's type has a constraint based on another member's type.
                                  #Examples:
                                  #  - [NUM, NUM2], where NUM2 > NUM
                                  #  - FUNC(NUM)->ARR, where ARR.length === NUM


                                             /=+===============================+=\
                                            /  :                               :  \
                                            )==:            SAFETY             :==(
                                            \  :_______________________________:  /
                                             \=+===============================+=/


{'fraction_non_alphanumeric': 0.1589386575594378, 'fraction_numerical': 0.0007881255746748983, 'mean_word_length': 0.7132088208820883, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 29, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 252, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '2486432', 'n_tokens_mistral': 4982, 'n_tokens_neox': 4781, 'n_words': 782}