Skip to content

Instantly share code, notes, and snippets.

@DQNEO
Last active April 28, 2021 16:12
Show Gist options
  • Save DQNEO/ee20707feceba883c48e329276ac681d to your computer and use it in GitHub Desktop.
Save DQNEO/ee20707feceba883c48e329276ac681d to your computer and use it in GitHub Desktop.
Words frequency in Go's spec
1 semicolons NNPS
1 iota NN
1 iota NNP
1 embeds VBZ
1 close NNP
1 snippets NNS
1 gives VBZ
1 informally RB
1 selection NN
1 specification NNP
1 terminators NNS
1 hexadecimal NNP
1 site NN
1 jan NNP
1 three-digit JJ
1 multi-dimensional JJ
1 accesses VBZ
1 resolve VB
1 begins NNS
1 non-variadic JJ
1 canonicalized VBN
1 computed VBN
1 mind NN
1 parse VB
1 ensure VB
1 bounds NNS
1 imaginary NNP
1 mixed VBN
1 segment NN
1 shared VBN
1 entering VBG
1 automatic JJ
1 graphic NNP
1 independently RB
1 excludes VBZ
1 events NNS
1 break NNP
1 switches NNS
1 types—may RB
1 communicate VB
1 incur VB
1 subsequent JJ
1 less JJR
1 constituents NNS
1 attempting VBG
1 non-terminals NNS
1 program-defined JJ
1 word NN
1 further JJ
1 parentheses VBZ
1 tuple JJ
1 steps NNS
1 period NN
1 unimported JJ
1 appending VBG
1 generator NN
1 overwrite VB
1 stops NNS
1 facilities NNS
1 issues NNS
1 entirely RB
1 placeholder NN
1 encounters VBZ
1 removes VBZ
1 contiguous JJ
1 measure NN
1 extra JJ
1 substitution NN
1 fall VBP
1 top-to-bottom JJ
1 or NNP
1 effects NNS
1 immutable JJ
1 square JJ
1 conditionally RB
1 goto NNP
1 make VB
1 launch VB
1 significantly RB
1 newline NN
1 multiplied VBN
1 not-a-number JJ
1 unary NNP
1 exclude VB
1 match VB
1 initializes VBZ
1 dependency NN
1 solely RB
1 term NN
1 types VBZ
1 what WP
1 send JJ
1 interface-valued JJ
1 times NNS
1 introduction NN
1 scoping NN
1 permits VBZ
1 yielding VBG
1 no-op JJ
1 implementations NNS
1 compare VBP
1 safety NN
1 failure NN
1 light-weight JJ
1 uniform JJ
1 representability NNP
1 right-hand-side JJ
1 second NNP
1 routine NN
1 erroneously RB
1 callers NNS
1 accented JJ
1 left- JJ
1 here RB
1 inserted VBN
1 eight CD
1 sieve NN
1 enough RB
1 limited JJ
1 import NNP
1 deferred VBN
1 manipulating VBG
1 specially RB
1 affect VBP
1 build JJ
1 subset NN
1 room NN
1 indicate VB
1 redeclare VB
1 documented VBN
1 language NNP
1 round NNP
1 initialization—variable JJ
1 triggers NNS
1 integral JJ
1 read VB
1 vocabulary NN
1 setting VBG
1 sequentially RB
1 incoming NN
1 initializer JJ
1 survive VBP
1 causing VBG
1 identifying VBG
1 exports NNS
1 unordered JJ
1 kinds NNS
1 qualifier NN
1 structured NNP
1 structured JJ
1 assignability NNP
1 copy NN
1 receive-only JJ
1 terminated VBN
1 requirements NNS
1 higher-dimensional JJ
1 parsing JJ
1 finally RB
1 reproducible JJ
1 low JJ
1 breaking VBG
1 differently RB
1 value-receiver JJ
1 linguistic JJ
1 accurately RB
1 execute VB
1 correct JJ
1 allowed VBN
1 chooses VBZ
1 opposed VBN
1 sometimes RB
1 alone RB
1 deterministically RB
1 consisting VBG
1 halves NNS
1 surrogate JJ
1 too RB
1 repetition NN
1 regardless RB
1 regardless NNP
1 operator NNP
1 braces NNS
1 included VBN
1 specifier NN
1 group NN
1 sends NNS
1 equals VBZ
1 resumes NNS
1 general NNP
1 reflect VB
1 descriptor NN
1 function-local JJ
1 ebnf NNP
1 ordering NN
1 arises NNS
1 produce VB
1 formal JJ
1 run VBN
1 superset NN
1 controls VBZ
1 sufficiently RB
1 portable JJ
1 efficient JJ
1 shortvardecl NNP
1 compares VBZ
1 turn NN
1 belongs VBZ
1 belongs NNS
1 channels NNP
1 traversed VBD
1 printing NN
1 table NN
1 multi-variable JJ
1 pseudo-random JJ
1 first NNP
1 impossible JJ
1 multiplication NN
1 side-effects NNS
1 introduced VBN
1 idiomatic JJ
1 closures NNS
1 booleans NNS
1 simple JJ
1 inherit VB
1 sequential JJ
1 phases NNS
1 entries NNS
1 hypothetical JJ
1 blank NNP
1 passing NN
1 passing VBG
1 implicit NN
1 length NNP
1 conditional JJ
1 share NN
1 varspec NNP
1 path NN
1 documents NNS
1 concrete JJ
1 preventing VBG
1 calculated VBN
1 assume NNP
1 creation NN
1 nnn JJ
1 influence NN
1 enforces VBZ
1 tested VBN
1 enumerations NNS
1 carried VBN
1 comprising VBG
1 uniqueness NNP
1 brace-bound JJ
1 flows VBZ
1 reported VBN
1 development NN
1 occupy VB
1 nest JJS
1 violate VBP
1 depending VBG
1 limit NN
1 truncation NN
1 duplicate NN
1 formats NNS
1 dynamically RB
1 state NN
1 defining VBG
1 adding VBG
1 describes VBZ
1 cost NN
1 modify VB
1 lower JJR
1 includes VBZ
1 byte-wise NN
1 unit NN
1 generated VBN
1 field NNP
1 differ VB
1 label NNP
1 semantically RB
1 executes NNS
1 directory NN
1 invoking VBG
1 factor NN
1 grow VB
1 spelled VBN
1 top-level JJ
1 stepwise NN
1 looks VBZ
1 production NN
1 items NNS
1 differs NNS
1 pointed VBN
1 attempt NN
1 termination NN
1 exploits VBZ
1 disassemble JJ
1 subexpressions NNS
1 completeness NN
1 garbage-collected JJ
1 backus-naur JJ
1 continue NN
1 continue NNP
1 continue VBP
1 curly RB
1 compile JJ
1 inhabit NN
1 support NN
1 sender NN
1 encouraged VBN
1 unnamed JJ
1 levels NNS
1 add VB
1 rewritten VBN
1 form NNP
1 repeating VBG
1 records NNS
1 process NN
1 nd NNP
1 reports VBZ
1 separates VBZ
1 nan NNP
1 specifically RB
1 types—array NN
1 elementary JJ
1 direct VB
1 control NN
1 backslashes NNS
1 repository NN
1 embeddedfield NNP
1 originally RB
1 already RB
1 allocation NNP
1 round-to-even JJ
1 parsed VBN
1 negation NN
1 lt NNP
1 restrict VB
1 requirement NN
1 collectively RB
1 becomes VBZ
1 fraction NN
1 go VBP
1 introducing VBG
1 nn JJ
1 simplified VBD
1 extract VB
1 allowing VBG
1 false JJ
1 nul NNP
1 portability NN
1 choice NN
1 camelcase NNP
1 encode NN
1 reflection NN
1 show VBP
1 insertion NN
1 size NNP
1 lengths NNS
1 width NN
1 correspond NN
1 restrictions NNS
1 cyclic JJ
1 uninterpreted JJ
1 reach VB
1 flow VB
1 compilers NNS
1 nearest JJS
1 objects NNS
1 normal JJ
1 prime JJ
1 golang.org NN
1 bound NN
1 computation NN
1 allows VBZ
1 importpaths NNP
1 considerations NNS
1 general-purpose JJ
1 relation NN
1 exits VBZ
1 nothing NN
1 skips PDT
1 enables VBZ
1 spec NN
1 permissible JJ
1 succeeded VBD
1 non-complex JJ
1 suppose VB
1 done VBN
1 architecture NN
1 multiply NN
1 dereferenced VBN
1 disallowed VBN
1 accommodate VB
1 encompasses VBZ
1 common JJ
1 initializers NNS
1 relationships NNS
1 sent NN
1 queues NNS
1 typically RB
1 repeatedly RB
1 minimum NN
1 computer NNP
1 aligned VBN
1 permitting VBG
1 non-interface NN
1 fused JJ
1 fused VBN
1 assumption NN
1 forms VBP
1 typespec NNP
1 cycles NNS
1 largest JJS
1 unparenthesized JJ
1 vetted VBN
1 entire JJ
1 component NN
1 irrespective NN
1 initialization NNP
1 detail NN
1 divided VBN
1 ellipsis NN
1 computes VBZ
1 circumstances NNS
1 fully RB
1 typename NNP
1 typename NN
1 backslash NN
1 compact JJ
1 entities NNS
1 rare JJ
1 current NNP
1 imports NNS
1 broken VBN
1 reserves NNS
1 constrained VBN
1 type-specific JJ
1 ranges NNS
1 conflict VB
1 marked VBN
1 architecture-independent JJ
1 embedding VBG
1 manual NN
1 extend VB
1 derived VBN
1 legally RB
1 expressed VBN
1 alias NNP
1 first-in-first-out JJ
1 structure NN
1 earlier RBR
1 manually RB
1 strongest JJS
1 own JJ
1 greater JJR
1 convenience NN
1 extended VBN
1 class NN
1 constraint NN
1 multi-way JJ
1 thread NN
1 category NN
1 category NNP
1 backward JJ
1 two-digit JJ
1 inverse NN
1 overlaps VBP
1 empty RB
1 related JJ
1 changes VBZ
1 precise JJ
1 raw NNP
1 called VBN
1 omitting VBG
1 optimize VB
1 assemble JJ
1 documentation NN
1 pass VB
1 reachable JJ
1 matching VBG
1 labeling VBG
1 functions—happens NNS
1 non- JJ
1 satisfies VBZ
1 protects VBZ
1 strongly RB
1 defers VBZ
1 number NNP
1 assembly NN
1 addressability NN
1 ascii NNP
1 fewer JJR
1 hierarchy NN
1 low-level JJ
1 information NN
1 composes VBZ
1 wide JJ
1 overriding VBG
1 immaterial JJ
1 version NNP
1 easy JJ
1 serve VBP
1 raised VBN
1 indirectly RB
1 quoted VBN
1 map NNP
1 switch NNP
1 designed VBN
1 scopes VBZ
1 instructions NNS
1 advances NNS
1 inclusive JJ
1 return NNP
1 speaking VBG
1 characters NNPS
1 non-constants NNS
1 reverse NN
1 carriage NNP
1 carriage NN
1 manage VB
1 wishes VBZ
1 non-decimal JJ
1 top JJ
1 loosely RB
1 illustrates VBZ
1 recent JJ
1 still RB
1 marking VBG
1 variants NNS
1 highest JJS
1 index NNP
1 internal JJ
1 useful JJ
1 offset NN
1 stream NN
1 rounds VBZ
1 indirects VBZ
1 single-character JJ
1 specifications NNS
1 typeswitchcase NNP
1 advance VB
1 integrated JJ
1 standard NNP
1 representations NNS
1 deletion NN
1 bit NN
1 concatenated VBN
1 successful JJ
1 set VBN
1 structurally RB
1 exist VB
1 sharing VBG
1 moreover RB
1 prevents VBZ
1 states VBZ
1 lm NNP
1 white NNP
1 formed VBN
1 predeclared VBD
1 others NNS
1 int NN
1 ll NNP
1 signatures NNS
1 defer NNP
1 hold VB
1 longest JJS
1 multi-byte NN
1 organization NN
1 annotated VBN
1 utf-8-encoded NNP
1 multi-character JJ
1 position NN
1 behave VBP
1 delivered VBN
1 full NNP
1 fusion NN
1 letter NNP
1 holding VBG
1 consist VBP
1 conventional JJ
1 management NN
1 labels NNP
1 discussion NN
1 remains VBZ
1 errors NNPS
1 errors NNS
1 and NNP
1 bootstrapping NNP
1 bootstrapping VBG
1 written VBN
1 redeclared VBN
1 reaches NNS
1 simplicity NN
1 convert VB
1 incdec JJ
1 making VBG
1 environments NNS
1 modulo JJ
1 pointing VBG
1 stay VB
1 analyzed VBN
1 power NN
1 line NNP
1 programming NNP
1 specifying VBG
1 synchronization NN
1 see NNP
1 limits NNS
1 shifted VBN
1 leftmost NN
1 clauses NNS
1 interpretation NN
1 implied VBN
1 lo NNP
1 overflow NNP
1 sum NN
1 textual JJ
1 dereference VB
1 copying VBG
1 available JJ
1 keywords VB
1 get VBP
1 involves VBZ
1 fma NNP
1 plain NN
1 re-uses VBZ
1 identified VBN
1 literally RB
1 ordered VBN
1 tabs NN
1 leading VBG
1 twice RB
1 running NN
1 predeclares VBZ
1 receive NNP
1 receive VBP
1 wrap NN
1 anew RB
1 n-bit JJ
1 minimal JJ
1 alternatives NNS
1 attribute NN
1 relationship NN
1 notation NNP
1 binding NN
1 selecting VBG
2 exact JJ
2 select NN
2 system NN
2 productions NNS
2 obtained VBN
2 specification NN
2 come VB
2 zero-size JJ
2 contents NNS
2 invokes VBZ
2 definition NN
2 reporting NN
2 complement NN
2 repeated JJ
2 architectures VBZ
2 contrast NN
2 unbuffered JJ
2 accepts VBZ
2 short NNP
2 combining VBG
2 bind VBP
2 multiple NNP
2 implementation-defined JJ
2 dividend NN
2 increment NN
2 earliest JJS
2 parentheses NNS
2 reserved VBN
2 installed VBD
2 ordinary JJ
2 skipped VBN
2 rune NNP
2 components NNS
2 consequence NN
2 exp NN
2 match VBP
2 dependency NNP
2 copied VBN
2 horizontal JJ
2 previously RB
2 original JJ
2 unspecified JJ
2 remain VBP
2 step NN
2 target NN
2 radix NN
2 referred VBN
2 removed VBN
2 quotient NN
2 ready JJ
2 independent JJ
2 computing VBG
2 mask NN
2 compile-time JJ
2 chosen VBN
2 irrelevant JJ
2 stop VB
2 assign VB
2 ignore VB
2 later RB
2 replacement NN
2 tokens JJ
2 truth NN
2 complete VB
2 complete JJ
2 scales VBZ
2 ignoring VBG
2 associativity NN
2 data NNS
2 bidirectional JJ
2 received VBN
2 hidden JJ
2 contexts NNS
2 sends VBZ
2 redeclaration NN
2 branches NNS
2 unchanged JJ
2 allocating VBG
2 nested JJ
2 presented VBN
2 wait VB
2 elsewhere RB
2 intermediate JJ
2 reached VBD
2 store VB
2 channels NNS
2 comparing VBG
2 fit VB
2 labeled VBN
2 just RB
2 readability NN
2 normally RB
2 indication NN
2 simplest JJS
2 linking VBG
2 opening NN
2 union NN
2 declares VBZ
2 assume VB
2 equality NN
2 rounded VBN
2 additionally RB
2 apply RB
2 literaltype NNP
2 hint NN
2 indexed VBN
2 identifiers NNPS
2 how WRB
2 transitively RB
2 beginning VBG
2 erroneous JJ
2 identify VB
2 words NNS
2 real JJ
2 sizes NNS
2 blocks NNP
2 blocks NNS
2 lu NNP
2 embed VB
2 jump NN
2 importpath NNP
2 one-dimensional JJ
2 added VBN
2 guard NN
2 occur VB
2 according VBG
2 listing VBG
2 interface NNP
2 large JJ
2 shares NNS
2 kind NN
2 explicit NNP
2 produces VBZ
2 derive VB
2 encoding NN
2 callable JJ
2 scoped NNS
2 concatenation NN
2 assertions NNS
2 right VB
2 prefixed VBN
2 happen VB
2 five CD
2 nil JJ
2 performed VBN
2 lower-case JJ
2 avoid VB
2 implemented VBD
2 implementation-specific JJ
2 preceding VBG
2 shallowest NN
2 iterates VBZ
2 defines VBZ
2 infinite JJ
2 supported VBN
2 returning VBG
2 location NN
2 serves VBZ
2 forclause NNP
2 accent NN
2 determine VB
2 controlled VBN
2 represent JJ
2 maximum JJ
2 systems NNS
2 referenced VBN
2 octal JJ
2 octal NN
2 place NN
2 blocking VBG
2 accept VB
2 item NN
2 recvexpr NNP
2 concatenating VBG
2 current JJ
2 imports VBZ
2 existing VBG
2 use VB
2 necessary JJ
2 utf-8 NNP
2 ways NNS
2 spaces NNS
2 consequently RB
2 extended JJ
2 trigger VBP
2 meaning NN
2 panicking NN
2 concurrently RB
2 unescaped JJ
2 communications NNS
2 instruction NN
2 well RB
2 hand NN
2 invoke VB
2 classes NNS
2 generates VBZ
2 numbered JJ
2 enclosing VBG
2 functionality NN
2 completes VBZ
2 retrieved VBN
2 floating VBG
2 unqualified JJ
2 extent NN
2 entity NN
2 standard VBN
2 standard NN
2 fits VBZ
2 give VB
2 brackets NNS
2 local JJ
2 placed VBN
2 channel NNP
2 assist VB
2 references VBZ
2 write VB
2 exists VBZ
2 copies VBZ
2 predeclared VBN
2 associate NN
2 initialize VB
2 moment NN
2 document NN
2 mark NN
2 parameter NNP
2 rounding VBG
2 allocated VBN
2 labels NNS
2 keyword NN
2 discussed VBN
2 discard VB
2 visible JJ
2 appends VBZ
2 determines VBZ
2 numeric NNP
2 recursively RB
2 long RB
2 rely VB
2 identifierlist NNP
2 receiving VBG
2 associates VBZ
2 pointer-receiver JJ
2 high JJ
2 applying VBG
2 re-used JJ
2 increasing VBG
2 transfers NNS
2 sending VBG
2 buffered JJ
2 decrement JJ
2 notation NN
2 input NN
2 binding VBG
3 similar JJ
3 hexadecimal JJ
3 determined VBN
3 act VBP
3 refer VB
3 operators NNPS
3 categories NNS
3 denoted VBN
3 brace NN
3 switches VBZ
3 else RB
3 closing VBG
3 comparison NNP
3 invocation NN
3 receives NNS
3 further RBR
3 treated VBN
3 indexing NN
3 permit VB
3 assigning VBG
3 newline JJ
3 creates VBZ
3 unary JJ
3 analysis NN
3 tag NN
3 start VB
3 remainder NN
3 enclosed VBN
3 tools NNS
3 implementation-dependent JJ
3 closed VBN
3 invocations NNS
3 main JJ
3 source NNP
3 taking VBG
3 restricted VBN
3 double JJ
3 succeeds VBZ
3 recvstmt NNP
3 larger JJR
3 handling VBG
3 goroutines NNS
3 precisely RB
3 certain JJ
3 matches NNS
3 typeswitchguard NNP
3 indirection NN
3 arithmetic NN
3 arithmetic JJ
3 destination NN
3 elide VB
3 thus NNP
3 buffer NN
3 guarantees NNS
3 possible JJ
3 anonymous JJ
3 parts NNS
3 define VB
3 require VB
3 versa NN
3 quote NN
3 addresses NNS
3 initializing VBG
3 program NNP
3 otherwise VB
3 allow VBP
3 comparisons NNS
3 temporary JJ
3 encoded VBN
3 construction NN
3 accessed VBN
3 listed VBN
3 mantissa NN
3 introduce VB
3 vice NN
3 level NN
3 accessible JJ
3 terms NNS
3 relative VBP
3 sign JJ
3 combine VB
3 indirections NNS
3 iterations NNS
3 semicolon NN
3 right-hand JJ
3 underscores NNS
3 particular JJ
3 replaced VBN
3 more RBR
3 saved VBD
3 note NN
3 names NNS
3 due JJ
3 substring NN
3 rather RB
3 compiled JJ
3 identity NN
3 infinity NN
3 stands VBZ
3 equal JJ
3 include VB
3 lexically RB
3 qualified VBN
3 asserts VBZ
3 immediately RB
3 involving VBG
3 compatibility NN
3 panicking VBG
3 effect NN
3 satisfy VBP
3 automatically RB
3 concurrent JJ
3 vary VB
3 described VBN
3 consider VB
3 evaluate VBP
3 ignored VBN
3 yield VB
3 integers NNS
3 newlines NNS
3 bitwise NN
3 universe JJ
3 addressed VBN
3 ambiguity NN
3 way NN
3 defer NN
3 utf-8-encoded JJ
3 mechanism NN
3 properties NNS
3 full JJ
3 omit VB
3 purpose NN
3 known VBN
3 permitted VBN
3 line NN
3 constructs VBZ
3 said VBD
3 unable JJ
3 terminates VBZ
3 keywords NNS
3 ordered VBD
3 composed VBN
3 grammar NN
4 anywhere RB
4 semicolons NNS
4 various JJ
4 package VB
4 missing JJ
4 importing NN
4 terminating VBG
4 op JJ
4 defaults VBZ
4 slicing VBG
4 numbers NNS
4 directly RB
4 shifts NNS
4 definitions NNS
4 memory NN
4 divisor NN
4 punctuation NN
4 ready VBP
4 truncated VBN
4 named VBN
4 init NN
4 runes NNS
4 comments NNS
4 guaranteed VBN
4 several JJ
4 arbitrary JJ
4 elided VBN
4 exported VBN
4 individually RB
4 syntax NN
4 depends VBZ
4 addition NN
4 caller NN
4 thus RB
4 channels VB
4 single-valued JJ
4 count NN
4 upper JJ
4 labeled JJ
4 slice NNP
4 starts VBZ
4 been VBN
4 made VBN
4 returned VBN
4 calls NNS
4 constspec NNP
4 four CD
4 true JJ
4 left-to-right JJ
4 executes VBZ
4 innermost NN
4 programs NNS
4 ieee-754 JJ
4 returns NNS
4 disallow VB
4 static JJ
4 refers NNS
4 context NN
4 forever RB
4 division NN
4 branch NN
4 preceded VBN
4 utf-8 JJ
4 non-exported JJ
4 create VB
4 raw JJ
4 optionally RB
4 package-level NN
4 specific JJ
4 underscore JJ
4 pointers NNS
4 nth JJ
4 behavior NN
4 ieee NNP
4 results NNS
4 comment NN
4 back RB
4 therefore RB
4 variadic JJ
4 programming NN
4 rule NN
4 post NN
4 provide VBP
4 interpreted VBN
4 terminates NNS
4 integer JJR
4 assigns VBZ
4 method NNP
5 invalid JJ
5 loop NN
5 required VBN
5 break NN
5 belonging VBG
5 letters NNS
5 respectively RB
5 produced VBN
5 three CD
5 conditions NNS
5 follows VBZ
5 selectors NNS
5 associated JJ
5 closed JJ
5 prefix NN
5 tokens NNS
5 tags NNS
5 consists VBZ
5 however RB
5 ends VBZ
5 compared VBN
5 proceeds NNS
5 control VBP
5 applied VBD
5 appears VBZ
5 discarded VBN
5 yet RB
5 precedence NN
5 sliced JJ
5 selected VBN
5 allocates VBZ
5 interfaces NNS
5 backslash JJ
5 stored VBN
5 alias NN
5 qualified JJ
5 acts VBZ
5 structs NNS
5 packagename NNP
5 space NN
5 rounding NN
5 applies NNS
5 direction NN
5 discovered VBN
5 previous JJ
5 similarly RB
5 lists NNS
6 cause VB
6 legal JJ
6 function NNP
6 usual JJ
6 goto NN
6 initial JJ
6 even RB
6 occurs NN
6 occurs NNS
6 sequences VBZ
6 starting VBG
6 equivalent JJ
6 general JJ
6 depth NN
6 promoted VBN
6 uses VBZ
6 regular JJ
6 alignment NN
6 bits NNS
6 logical JJ
6 resulting VBG
6 sent VBN
6 construct NN
6 multi-valued JJ
6 forms NNS
6 represented VBN
6 access NN
6 do VBP
6 maps NNS
6 denote VBP
6 together RB
6 exception NN
6 evaluating VBG
6 key NN
6 examples NNS
6 constructed VBN
6 inner JJ
6 letter NN
6 instead RB
6 lexical JJ
6 provided VBN
6 panics NNS
6 reference NN
6 considered VBN
7 hexadecimal NN
7 left-hand JJ
7 begins VBZ
7 provides VBZ
7 dependencies NNS
7 comparison NN
7 unsigned JJ
7 specify VB
7 implements VBZ
7 absent JJ
7 received JJ
7 primary JJ
7 change VBP
7 implicit JJ
7 last JJ
7 were VBD
7 boolean NN
7 type NNP
7 explicitly RB
7 surrounding VBG
7 one CD
7 typed JJ
7 take VB
7 non-interface JJ
7 referring VBG
7 fractional JJ
7 present VB
7 exponent NN
7 representation NN
7 assignments NNS
7 representing VBG
7 signed VBN
7 causes VBZ
7 non-empty JJ
7 keys NNS
7 was VBD
7 optional JJ
7 actual JJ
7 shorthand NN
7 implementation NN
8 token NN
8 terminating NN
8 never RB
8 assertion NN
8 language NN
8 exported JJ
8 individual JJ
8 simple NN
8 final JJ
8 evaluates VBZ
8 imported VBN
8 blocks VBZ
8 declare VB
8 binary JJ
8 points NNS
8 bound VBN
8 conversions NNS
8 storage NN
8 calling VBG
8 omitted VBN
8 entry NN
8 present JJ
8 including VBG
8 non-negative JJ
8 additional JJ
8 escapes NNS
8 holds VBZ
8 executing VBG
8 see VB
8 passed VBD
8 overflow NN
9 most JJS
9 contain VB
9 second JJ
9 uninitialized JJ
9 takes VBZ
9 variable JJ
9 sets VBZ
9 right NN
9 successive JJ
9 signature NN
9 strings NNS
9 binds VBZ
9 denoting VBG
9 implementation NNP
9 invoked VBN
10 select JJ
10 side NN
10 files NNS
10 imaginary JJ
10 valid JJ
10 converting VBG
10 operator NN
10 implement VB
10 label NN
10 least JJS
10 negative JJ
10 byte NN
10 size NN
10 unique JJ
10 evaluation NN
10 next JJ
10 use VBP
10 proceed VB
10 contains VBZ
10 so RB
10 return NN
10 once RB
10 restriction NN
10 addressable JJ
11 body NN
11 short JJ
11 multiple NN
11 floating-point JJ
11 decimal JJ
11 program NN
11 parenthesized VBN
11 non-blank JJ
11 embedded JJ
11 where WRB
11 selector NN
11 respective JJ
11 non-constant JJ
11 quotes NNS
11 panic NN
11 created VBN
11 specifies VBZ
12 cases NNS
12 cannot VBP
12 packages NNS
12 exactly RB
12 slices NNS
12 more JJR
12 communication NN
12 zero CD
12 goroutine NN
12 section NN
12 address NN
12 example NN
12 text NN
13 condition NN
13 import NN
13 calls VBZ
13 conversion NN
13 representable JJ
13 compiler NN
13 dynamic JJ
13 represents VBZ
13 containing VBG
13 end NN
13 precision NN
13 arrays NNS
14 rules NNS
14 denotes VBZ
14 string NN
14 distinct JJ
14 rune NN
14 error NN
14 equivalent NN
14 whose WP$
14 apply VBP
14 special JJ
14 illegal JJ
14 indices NNS
14 characters NNS
14 base NN
15 assigned VBN
15 send VB
15 deferred JJ
15 executed VBN
15 left NN
15 run VB
15 then RB
15 literal JJ
15 returns VBZ
15 shift NN
15 panic JJ
15 implicitly RB
16 sequence NN
16 receive NN
17 bytes NNS
17 point NN
17 blank JJ
17 comparable JJ
17 followed VBN
17 names VBZ
17 fields NNS
17 composite JJ
17 equal VB
17 scope NN
17 time NN
17 possibly RB
18 yields NNS
18 explicit JJ
18 go NNP
18 digits NNS
18 switch VB
18 integer NN
19 default NN
19 converted VBN
19 always RB
19 represent VBP
19 empty JJ
19 assignable JJ
19 predeclared JJ
19 parameter NN
20 unicode NNP
20 capacity NN
20 switch NN
20 numeric JJ
21 appear VBP
21 array VB
21 part NN
22 parameters NNS
22 specified VBN
22 constant NN
22 boolean JJ
22 corresponding JJ
22 different JJ
22 does VBZ
22 argument NN
22 instance NN
22 operations NNS
23 code NN
23 file NN
23 initialized VBN
23 new JJ
23 key JJ
24 clause NN
24 identifiers NNS
24 arguments NNS
24 operation NN
25 source NN
25 defined VBN
25 otherwise RB
25 zero NN
26 underlying VBG
26 assignment NN
26 return VB
27 such JJ
27 also RB
28 operands NNS
28 length NN
28 form NN
28 only RB
28 single JJ
28 character NN
29 methods NNS
29 evaluated VBN
30 using VBG
30 given VBN
30 range NN
30 order NN
30 floating-point NN
30 when WRB
30 number NN
30 following VBG
30 run-time JJ
31 call NN
31 declarations NNS
31 execution NN
31 used VBN
31 literals NNS
32 list NN
33 operators NNS
33 built-in JJ
33 first JJ
33 initialization NN
34 complex JJ
34 identical JJ
35 iteration NN
35 called VBD
36 other JJ
37 struct NN
38 name NN
38 receiver NN
38 has VBZ
41 block NN
41 index NN
42 operand NN
43 there EX
43 field NN
43 elements NNS
43 declared VBN
44 all PDT
45 functions NNS
45 pointer NN
45 integer JJ
46 constants NNS
48 case NN
48 statements NNS
48 set NN
49 declaration NN
49 variables NNS
50 two CD
50 untyped JJ
51 literal NN
51 have VB
51 map NN
52 array NN
54 one NN
54 expressions NNS
59 element NN
60 interface NN
60 channel NN
62 result NN
65 string VBG
71 identifier NN
74 same JJ
81 package NN
87 types NNS
87 variable NN
94 slice NN
95 constant JJ
97 statement NN
98 method NN
112 values NNS
118 not RB
120 expression NN
168 function NN
223 value NN
230 be VB
243 are VBP
363 to TO
442 type NN
579 is VBZ
1547 Total
@DQNEO
Copy link
Author

DQNEO commented Apr 28, 2021

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment