0s autopkgtest [07:04:34]: starting date and time: 2026-02-10 07:04:34+0000 0s autopkgtest [07:04:34]: git checkout: 508d4a25 a-v-ssh wait_for_ssh: demote "ssh connection failed" to a debug message 0s autopkgtest [07:04:34]: host juju-7f2275-prod-proposed-migration-environment-9; command line: /home/ubuntu/autopkgtest/runner/autopkgtest --output-dir /tmp/autopkgtest-work.tud2gu12/out --timeout-copy=6000 --setup-commands 'ln -s /dev/null /etc/systemd/system/bluetooth.service; printf "http_proxy=http://squid.internal:3128\nhttps_proxy=http://squid.internal:3128\nno_proxy=127.0.0.1,127.0.1.1,localhost,localdomain,internal,login.ubuntu.com,archive.ubuntu.com,ports.ubuntu.com,security.ubuntu.com,ddebs.ubuntu.com,changelogs.ubuntu.com,keyserver.ubuntu.com,launchpadlibrarian.net,launchpadcontent.net,launchpad.net,keystone.ps5.canonical.com,objectstorage.prodstack5.canonical.com,radosgw.ps5.canonical.com\n" >> /etc/environment' --apt-pocket=proposed=src:ruby-concurrent --apt-upgrade ruby-immutable-ruby --timeout-short=300 --timeout-copy=20000 --timeout-build=20000 --env=ADT_TEST_TRIGGERS=ruby-concurrent/1.3.6-1 -- lxd -r lxd-armhf-10.145.243.79 lxd-armhf-10.145.243.79:autopkgtest/ubuntu/resolute/armhf 22s autopkgtest [07:04:56]: testbed dpkg architecture: armhf 24s autopkgtest [07:04:58]: testbed apt version: 3.1.15 28s autopkgtest [07:05:02]: @@@@@@@@@@@@@@@@@@@@ test bed setup 31s autopkgtest [07:05:05]: testbed release detected to be: None 39s autopkgtest [07:05:13]: updating testbed package index (apt update) 42s Get:1 http://ftpmaster.internal/ubuntu resolute-proposed InRelease [124 kB] 42s Get:2 http://ftpmaster.internal/ubuntu resolute InRelease [124 kB] 42s Hit:3 http://ftpmaster.internal/ubuntu resolute-updates InRelease 42s Hit:4 http://ftpmaster.internal/ubuntu resolute-security InRelease 43s Get:5 http://ftpmaster.internal/ubuntu resolute-proposed/main Sources [178 kB] 43s Get:6 http://ftpmaster.internal/ubuntu resolute-proposed/universe Sources [1727 kB] 45s Get:7 http://ftpmaster.internal/ubuntu resolute-proposed/multiverse Sources [31.1 kB] 45s Get:8 http://ftpmaster.internal/ubuntu resolute-proposed/main armhf Packages [249 kB] 46s Get:9 http://ftpmaster.internal/ubuntu resolute-proposed/universe armhf Packages [1556 kB] 48s Get:10 http://ftpmaster.internal/ubuntu resolute-proposed/multiverse armhf Packages [8156 B] 48s Get:11 http://ftpmaster.internal/ubuntu resolute/main Sources [1404 kB] 51s Get:12 http://ftpmaster.internal/ubuntu resolute/universe Sources [21.3 MB] 82s Get:13 http://ftpmaster.internal/ubuntu resolute/main armhf Packages [1386 kB] 83s Get:14 http://ftpmaster.internal/ubuntu resolute/universe armhf Packages [15.1 MB] 106s Fetched 43.2 MB in 1min 5s (662 kB/s) 107s Reading package lists... 114s autopkgtest [07:06:28]: upgrading testbed (apt dist-upgrade and autopurge) 115s Reading package lists... 116s Building dependency tree... 116s Reading state information... 116s Calculating upgrade... 117s The following packages will be upgraded: 117s libbrotli1 118s 1 upgraded, 0 newly installed, 0 to remove and 0 not upgraded. 118s Need to get 318 kB of archives. 118s After this operation, 0 B of additional disk space will be used. 118s Get:1 http://ftpmaster.internal/ubuntu resolute/main armhf libbrotli1 armhf 1.2.0-3 [318 kB] 119s Fetched 318 kB in 1s (478 kB/s) 119s (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 68691 files and directories currently installed.) 119s Preparing to unpack .../libbrotli1_1.2.0-3_armhf.deb ... 119s Unpacking libbrotli1:armhf (1.2.0-3) over (1.1.0-2build6) ... 119s Setting up libbrotli1:armhf (1.2.0-3) ... 119s Processing triggers for libc-bin (2.42-2ubuntu4) ... 122s Reading package lists... 122s Building dependency tree... 122s Reading state information... 123s Solving dependencies... 124s 0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded. 126s autopkgtest [07:06:40]: rebooting testbed after setup commands that affected boot 172s autopkgtest [07:07:26]: testbed running kernel: Linux 6.8.0-87-generic #88~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Oct 14 14:00:09 UTC 2 200s autopkgtest [07:07:54]: @@@@@@@@@@@@@@@@@@@@ apt-source ruby-immutable-ruby 212s Get:1 http://ftpmaster.internal/ubuntu resolute/universe ruby-immutable-ruby 0.1.0-2 (dsc) [2161 B] 212s Get:2 http://ftpmaster.internal/ubuntu resolute/universe ruby-immutable-ruby 0.1.0-2 (tar) [137 kB] 212s Get:3 http://ftpmaster.internal/ubuntu resolute/universe ruby-immutable-ruby 0.1.0-2 (diff) [2840 B] 212s gpgv: Signature made Sun Sep 17 20:14:42 2023 UTC 212s gpgv: using RSA key 4D0BE12F0E4776D8AACE9696E66C775AEBFE6C7D 212s gpgv: Can't check signature: No public key 212s dpkg-source: warning: cannot verify inline signature for ./ruby-immutable-ruby_0.1.0-2.dsc: no acceptable signature found 212s autopkgtest [07:08:06]: testing package ruby-immutable-ruby version 0.1.0-2 214s autopkgtest [07:08:08]: build not needed 217s autopkgtest [07:08:11]: test gem2deb-test-runner: preparing testbed 219s Reading package lists... 220s Building dependency tree... 220s Reading state information... 220s Solving dependencies... 221s The following NEW packages will be installed: 221s gem2deb-test-runner libruby libruby3.3 rake ruby ruby-concurrent ruby-csv 221s ruby-did-you-mean ruby-diff-lcs ruby-immutable-ruby ruby-minitest 221s ruby-net-telnet ruby-power-assert ruby-rbtree ruby-rspec ruby-rspec-core 221s ruby-rspec-expectations ruby-rspec-mocks ruby-rspec-support 221s ruby-ruby2-keywords ruby-rubygems ruby-sorted-set ruby-test-unit 221s ruby-webrick ruby-xmlrpc ruby3.3 rubygems-integration 221s 0 upgraded, 27 newly installed, 0 to remove and 0 not upgraded. 221s Need to get 7101 kB of archives. 221s After this operation, 38.9 MB of additional disk space will be used. 221s Get:1 http://ftpmaster.internal/ubuntu resolute/main armhf rubygems-integration all 1.19build1 [5666 B] 222s Get:2 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-csv all 3.3.4-1 [43.0 kB] 222s Get:3 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-did-you-mean all 1.6.3-2build1 [14.9 kB] 222s Get:4 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-net-telnet all 0.2.0-1build1 [13.5 kB] 222s Get:5 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-ruby2-keywords all 0.0.5-1build1 [4398 B] 222s Get:6 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-webrick all 1.9.1-1build1 [60.9 kB] 222s Get:7 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-xmlrpc all 0.3.3-2build1 [24.9 kB] 222s Get:8 http://ftpmaster.internal/ubuntu resolute/main armhf libruby3.3 armhf 3.3.8-2ubuntu2 [5595 kB] 228s Get:9 http://ftpmaster.internal/ubuntu resolute/main armhf ruby3.3 armhf 3.3.8-2ubuntu2 [59.0 kB] 228s Get:10 http://ftpmaster.internal/ubuntu resolute/main armhf libruby armhf 1:3.3 [5162 B] 228s Get:11 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-rubygems all 3.6.7-2ubuntu2 [332 kB] 228s Get:12 http://ftpmaster.internal/ubuntu resolute/main armhf ruby armhf 1:3.3 [3670 B] 228s Get:13 http://ftpmaster.internal/ubuntu resolute/main armhf rake all 13.2.1-1build1 [45.9 kB] 229s Get:14 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-minitest all 5.26.1-1 [49.3 kB] 229s Get:15 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-power-assert all 3.0.1-1 [11.4 kB] 229s Get:16 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-test-unit all 3.6.2-1 [67.0 kB] 229s Get:17 http://ftpmaster.internal/ubuntu resolute/universe armhf gem2deb-test-runner armhf 2.2.5 [18.3 kB] 229s Get:18 http://ftpmaster.internal/ubuntu resolute-proposed/universe armhf ruby-concurrent all 1.3.6-1 [284 kB] 229s Get:19 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-diff-lcs all 1.5.1-1 [22.8 kB] 229s Get:20 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rbtree armhf 0.4.6-1build3 [20.5 kB] 229s Get:21 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-sorted-set all 1.0.3-3 [4258 B] 229s Get:22 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-immutable-ruby all 0.1.0-2 [47.1 kB] 229s Get:23 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-support all 3.13.0c0e0m0s1-2 [29.2 kB] 229s Get:24 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-core all 3.13.0c0e0m0s1-2 [164 kB] 229s Get:25 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-expectations all 3.13.0c0e0m0s1-2 [89.8 kB] 229s Get:26 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-mocks all 3.13.0c0e0m0s1-2 [81.0 kB] 230s Get:27 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec all 3.13.0c0e0m0s1-2 [3500 B] 230s Fetched 7101 kB in 8s (854 kB/s) 230s Selecting previously unselected package rubygems-integration. 230s (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 68691 files and directories currently installed.) 230s Preparing to unpack .../00-rubygems-integration_1.19build1_all.deb ... 230s Unpacking rubygems-integration (1.19build1) ... 230s Selecting previously unselected package ruby-csv. 230s Preparing to unpack .../01-ruby-csv_3.3.4-1_all.deb ... 230s Unpacking ruby-csv (3.3.4-1) ... 230s Selecting previously unselected package ruby-did-you-mean. 230s Preparing to unpack .../02-ruby-did-you-mean_1.6.3-2build1_all.deb ... 230s Unpacking ruby-did-you-mean (1.6.3-2build1) ... 230s Selecting previously unselected package ruby-net-telnet. 230s Preparing to unpack .../03-ruby-net-telnet_0.2.0-1build1_all.deb ... 230s Unpacking ruby-net-telnet (0.2.0-1build1) ... 231s Selecting previously unselected package ruby-ruby2-keywords. 231s Preparing to unpack .../04-ruby-ruby2-keywords_0.0.5-1build1_all.deb ... 231s Unpacking ruby-ruby2-keywords (0.0.5-1build1) ... 231s Selecting previously unselected package ruby-webrick. 231s Preparing to unpack .../05-ruby-webrick_1.9.1-1build1_all.deb ... 231s Unpacking ruby-webrick (1.9.1-1build1) ... 231s Selecting previously unselected package ruby-xmlrpc. 231s Preparing to unpack .../06-ruby-xmlrpc_0.3.3-2build1_all.deb ... 231s Unpacking ruby-xmlrpc (0.3.3-2build1) ... 231s Selecting previously unselected package libruby3.3:armhf. 231s Preparing to unpack .../07-libruby3.3_3.3.8-2ubuntu2_armhf.deb ... 231s Unpacking libruby3.3:armhf (3.3.8-2ubuntu2) ... 231s Selecting previously unselected package ruby3.3. 231s Preparing to unpack .../08-ruby3.3_3.3.8-2ubuntu2_armhf.deb ... 231s Unpacking ruby3.3 (3.3.8-2ubuntu2) ... 231s Selecting previously unselected package libruby:armhf. 231s Preparing to unpack .../09-libruby_1%3a3.3_armhf.deb ... 231s Unpacking libruby:armhf (1:3.3) ... 231s Selecting previously unselected package ruby-rubygems. 231s Preparing to unpack .../10-ruby-rubygems_3.6.7-2ubuntu2_all.deb ... 231s Unpacking ruby-rubygems (3.6.7-2ubuntu2) ... 232s Selecting previously unselected package ruby. 232s Preparing to unpack .../11-ruby_1%3a3.3_armhf.deb ... 232s Unpacking ruby (1:3.3) ... 232s Selecting previously unselected package rake. 232s Preparing to unpack .../12-rake_13.2.1-1build1_all.deb ... 232s Unpacking rake (13.2.1-1build1) ... 232s Selecting previously unselected package ruby-minitest. 232s Preparing to unpack .../13-ruby-minitest_5.26.1-1_all.deb ... 232s Unpacking ruby-minitest (5.26.1-1) ... 232s Selecting previously unselected package ruby-power-assert. 232s Preparing to unpack .../14-ruby-power-assert_3.0.1-1_all.deb ... 232s Unpacking ruby-power-assert (3.0.1-1) ... 232s Selecting previously unselected package ruby-test-unit. 232s Preparing to unpack .../15-ruby-test-unit_3.6.2-1_all.deb ... 232s Unpacking ruby-test-unit (3.6.2-1) ... 232s Selecting previously unselected package gem2deb-test-runner. 232s Preparing to unpack .../16-gem2deb-test-runner_2.2.5_armhf.deb ... 232s Unpacking gem2deb-test-runner (2.2.5) ... 232s Selecting previously unselected package ruby-concurrent. 232s Preparing to unpack .../17-ruby-concurrent_1.3.6-1_all.deb ... 232s Unpacking ruby-concurrent (1.3.6-1) ... 232s Selecting previously unselected package ruby-diff-lcs. 232s Preparing to unpack .../18-ruby-diff-lcs_1.5.1-1_all.deb ... 232s Unpacking ruby-diff-lcs (1.5.1-1) ... 232s Selecting previously unselected package ruby-rbtree. 232s Preparing to unpack .../19-ruby-rbtree_0.4.6-1build3_armhf.deb ... 232s Unpacking ruby-rbtree (0.4.6-1build3) ... 232s Selecting previously unselected package ruby-sorted-set. 232s Preparing to unpack .../20-ruby-sorted-set_1.0.3-3_all.deb ... 232s Unpacking ruby-sorted-set (1.0.3-3) ... 232s Selecting previously unselected package ruby-immutable-ruby. 232s Preparing to unpack .../21-ruby-immutable-ruby_0.1.0-2_all.deb ... 232s Unpacking ruby-immutable-ruby (0.1.0-2) ... 232s Selecting previously unselected package ruby-rspec-support. 232s Preparing to unpack .../22-ruby-rspec-support_3.13.0c0e0m0s1-2_all.deb ... 232s Unpacking ruby-rspec-support (3.13.0c0e0m0s1-2) ... 232s Selecting previously unselected package ruby-rspec-core. 232s Preparing to unpack .../23-ruby-rspec-core_3.13.0c0e0m0s1-2_all.deb ... 232s Unpacking ruby-rspec-core (3.13.0c0e0m0s1-2) ... 232s Selecting previously unselected package ruby-rspec-expectations. 232s Preparing to unpack .../24-ruby-rspec-expectations_3.13.0c0e0m0s1-2_all.deb ... 232s Unpacking ruby-rspec-expectations (3.13.0c0e0m0s1-2) ... 232s Selecting previously unselected package ruby-rspec-mocks. 232s Preparing to unpack .../25-ruby-rspec-mocks_3.13.0c0e0m0s1-2_all.deb ... 232s Unpacking ruby-rspec-mocks (3.13.0c0e0m0s1-2) ... 232s Selecting previously unselected package ruby-rspec. 232s Preparing to unpack .../26-ruby-rspec_3.13.0c0e0m0s1-2_all.deb ... 232s Unpacking ruby-rspec (3.13.0c0e0m0s1-2) ... 233s Setting up ruby-ruby2-keywords (0.0.5-1build1) ... 233s Setting up ruby-power-assert (3.0.1-1) ... 233s Setting up rubygems-integration (1.19build1) ... 233s Setting up ruby-concurrent (1.3.6-1) ... 233s Setting up ruby-minitest (5.26.1-1) ... 233s Setting up ruby-test-unit (3.6.2-1) ... 233s Setting up ruby-net-telnet (0.2.0-1build1) ... 233s Setting up ruby-csv (3.3.4-1) ... 233s Setting up ruby-rspec-support (3.13.0c0e0m0s1-2) ... 233s Setting up ruby-webrick (1.9.1-1build1) ... 233s Setting up ruby-did-you-mean (1.6.3-2build1) ... 233s Setting up ruby-xmlrpc (0.3.3-2build1) ... 233s Setting up rake (13.2.1-1build1) ... 233s Setting up libruby3.3:armhf (3.3.8-2ubuntu2) ... 233s Setting up ruby3.3 (3.3.8-2ubuntu2) ... 233s Setting up libruby:armhf (1:3.3) ... 233s Setting up ruby (1:3.3) ... 233s Setting up ruby-rbtree (0.4.6-1build3) ... 233s Setting up ruby-rspec-core (3.13.0c0e0m0s1-2) ... 233s Setting up ruby-diff-lcs (1.5.1-1) ... 233s Setting up ruby-rubygems (3.6.7-2ubuntu2) ... 233s Setting up ruby-sorted-set (1.0.3-3) ... 233s Setting up gem2deb-test-runner (2.2.5) ... 233s Setting up ruby-rspec-expectations (3.13.0c0e0m0s1-2) ... 233s Setting up ruby-rspec-mocks (3.13.0c0e0m0s1-2) ... 233s Setting up ruby-immutable-ruby (0.1.0-2) ... 233s Setting up ruby-rspec (3.13.0c0e0m0s1-2) ... 233s Processing triggers for libc-bin (2.42-2ubuntu4) ... 233s Processing triggers for man-db (2.13.1-1build1) ... 242s autopkgtest [07:08:36]: test gem2deb-test-runner: gem2deb-test-runner --autopkgtest --check-dependencies 2>&1 242s autopkgtest [07:08:36]: test gem2deb-test-runner: [----------------------- 244s 244s ┌──────────────────────────────────────────────────────────────────────────────┐ 244s │ Checking Rubygems dependency resolution on ruby3.3 │ 244s └──────────────────────────────────────────────────────────────────────────────┘ 244s 244s RUBYLIB=. GEM_PATH= ruby3.3 -e gem\ \"immutable-ruby\" 244s mv lib ./.gem2deb.lib 245s mv ./.gem2deb.lib lib 245s 245s ┌──────────────────────────────────────────────────────────────────────────────┐ 245s │ Run tests for ruby3.3 from debian/ruby-tests.rake │ 245s └──────────────────────────────────────────────────────────────────────────────┘ 245s 245s RUBYLIB=. GEM_PATH= ruby3.3 -S rake --rakelibdir /gem2deb-nonexistent -f debian/ruby-tests.rake 245s mv lib ./.gem2deb.lib 245s /usr/bin/ruby3.3 -I/usr/share/rubygems-integration/all/gems/rspec-support-3.13.1/lib:/usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/lib /usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/exe/rspec --pattern ./spec/\*\*/\*_spec.rb --format documentation 247s 247s Array 247s #to_list 247s returns an equivalent Immutable list 247s 247s Enumerable 247s #to_list 247s returns an equivalent list 247s works on Ranges 247s 247s IO 247s #to_list 247s with a File 247s returns an equivalent list 247s with a StringIO 247s returns an equivalent list 247s 247s Immutable::Deque 247s #clear 247s on [] 247s preserves the original 247s returns an empty deque 247s on ["A"] 247s preserves the original 247s returns an empty deque 247s on ["A", "B", "C"] 247s preserves the original 247s returns an empty deque 247s from a subclass 247s returns an instance of the subclass 247s 247s Immutable::Deque 247s .[] 247s with no arguments 247s always returns the same instance 247s returns an empty, frozen deque 247s with a number of items 247s always returns a different instance 247s is the same as repeatedly using #endeque 247s 247s Immutable::Deque 247s on [] 247s returns self 247s on ["A"] 247s returns self 247s on ["A", "B", "C"] 247s returns self 247s on [] 247s returns self 247s on ["A"] 247s returns self 247s on ["A", "B", "C"] 247s returns self 247s 247s Immutable::Deque 247s #dequeue 247s on [] 247s preserves the original 247s returns [] 247s on ["A"] 247s preserves the original 247s returns [] 247s on ["A", "B", "C"] 247s preserves the original 247s returns ["B", "C"] 247s on empty subclass 247s returns empty object of same class 247s #shift 247s on [] 247s preserves the original 247s returns [] 247s on ["A"] 247s preserves the original 247s returns [] 247s on ["A", "B", "C"] 247s preserves the original 247s returns ["B", "C"] 247s on empty subclass 247s returns empty object of same class 247s 247s Immutable::Deque 247s #empty? 247s on [] 247s returns true 247s on ["A"] 247s returns false 247s on ["A", "B", "C"] 247s returns false 247s after dedequeing an item from ["A", "B", "C"] 247s returns false 247s .empty 247s returns the canonical empty deque 247s from a subclass 247s returns an empty instance of the subclass 247s 247s Immutable::Deque 247s #enqueue 247s on [] with "A" 247s preserves the original 247s returns ["A"] 247s on ["A"] with "B" 247s preserves the original 247s returns ["A", "B"] 247s on ["A"] with "A" 247s preserves the original 247s returns ["A", "A"] 247s on ["A", "B", "C"] with "D" 247s preserves the original 247s returns ["A", "B", "C", "D"] 247s #push 247s on [] with "A" 247s preserves the original 247s returns ["A"] 247s on ["A"] with "B" 247s preserves the original 247s returns ["A", "B"] 247s on ["A"] with "A" 247s preserves the original 247s returns ["A", "A"] 247s on ["A", "B", "C"] with "D" 247s preserves the original 247s returns ["A", "B", "C", "D"] 247s 247s Immutable::Deque 247s #first 247s on [] 247s returns nil 247s on ["A"] 247s returns "A" 247s on ["A", "B", "C"] 247s returns "A" 247s 247s Immutable::Deque 247s #inspect 247s on [] 247s returns "Immutable::Deque[]" 247s returns a string which can be eval'd to get an equivalent object 247s on ["A"] 247s returns "Immutable::Deque[\"A\"]" 247s returns a string which can be eval'd to get an equivalent object 247s on ["A", "B", "C"] 247s returns "Immutable::Deque[\"A\", \"B\", \"C\"]" 247s returns a string which can be eval'd to get an equivalent object 247s 247s Immutable::Deque 247s #last 247s on [] 247s returns nil 247s on ["A"] 247s returns "A" 247s on ["A", "B", "C"] 247s returns "C" 247s 247s Immutable::Deque 247s #marshal_dump/#marshal_load 248s can survive dumping and loading into a new process 248s is still possible to push and pop items after loading 248s 248s Immutable::Deque 248s .new 248s accepts a single enumerable argument and creates a new deque 248s is amenable to overriding of #initialize 248s from a subclass 248s returns a frozen instance of the subclass 248s .[] 248s accepts a variable number of items and creates a new deque 248s 248s Immutable::Deque 248s #pop 248s on [] 248s preserves the original 248s returns [] 248s returns a frozen instance 248s on ["A"] 248s preserves the original 248s returns [] 248s returns a frozen instance 248s on ["A", "B", "C"] 248s preserves the original 248s returns ["A", "B"] 248s returns a frozen instance 248s on empty subclass 248s returns an empty object of the same class 248s 248s Immutable::Deque 248s #pretty_print 248s prints the whole Deque on one line if it fits 248s prints each item on its own line, if not 248s 248s Immutable::Deque 248s #push 248s pushing "A" into [] 248s preserves the original 248s returns ["A"] 248s returns a frozen instance 248s pushing "B" into ["A"] 248s preserves the original 248s returns ["A", "B"] 248s returns a frozen instance 248s pushing "D" into ["A", "B", "C"] 248s preserves the original 248s returns ["A", "B", "C", "D"] 248s returns a frozen instance 248s on a subclass 248s returns an object of same class 248s 248s Immutable::Deque 248s modification (using #push, #pop, #shift, and #unshift) 248s works when applied in many random combinations 248s 248s Immutable::Deque 248s #rotate 248s on [] 248s preserves the original 248s returns [] 248s returns a frozen instance 248s on ["A"] 248s preserves the original 248s returns ["A"] 248s returns a frozen instance 248s on ["A", "B", "C"] 248s preserves the original 248s returns ["B", "C", "A"] 248s returns a frozen instance 248s on ["A", "B", "C", "D"] 248s preserves the original 248s returns ["A", "B", "C", "D"] 248s returns a frozen instance 248s on ["A", "B", "C", "D"] 248s preserves the original 248s returns ["C", "D", "A", "B"] 248s returns a frozen instance 248s on a Deque with most items on 'front' list 248s works with a small rotation 248s works with a larger rotation 248s on a Deque with most items on 'rear' list 248s works with a small rotation 248s works with a larger rotation 248s on empty subclass 248s returns an empty object of the same class 248s 248s Immutable::Deque 248s #shift 248s on [] 248s preserves the original 248s returns [] 248s returns a frozen instance 248s on ["A"] 248s preserves the original 248s returns [] 248s returns a frozen instance 248s on ["A", "B", "C"] 248s preserves the original 248s returns ["B", "C"] 248s returns a frozen instance 248s 248s Immutable::Deque 248s #size 248s on [] 248s returns 0 248s on ["A"] 248s returns 1 248s on ["A", "B", "C"] 248s returns 3 248s #length 248s on [] 248s returns 0 248s on ["A"] 248s returns 1 248s on ["A", "B", "C"] 248s returns 3 248s 248s Immutable::Deque 248s #to_a 248s on [] 248s returns [] 248s returns a mutable array 248s on ["A"] 248s returns ["A"] 248s returns a mutable array 248s on ["A", "B", "C"] 248s returns ["A", "B", "C"] 248s returns a mutable array 248s #entries 248s on [] 248s returns [] 248s returns a mutable array 248s on ["A"] 248s returns ["A"] 248s returns a mutable array 248s on ["A", "B", "C"] 248s returns ["A", "B", "C"] 248s returns a mutable array 248s 248s Immutable::Deque 248s #to_ary 248s enables implicit conversion to 248s block parameters 248s method arguments 248s works with splat 248s 248s Immutable::Deque 248s #to_list 248s on [] 248s returns a list containing [] 248s on ["A"] 248s returns a list containing ["A"] 248s on ["A", "B", "C"] 248s returns a list containing ["A", "B", "C"] 248s after dedequeing an item from ["A", "B", "C"] 248s returns a list containing ["B", "C"] 248s 248s Immutable::Deque 248s #unshift 248s on [] with "A" 248s preserves the original 248s returns ["A"] 248s returns a frozen instance 248s on ["A"] with "B" 248s preserves the original 248s returns ["B", "A"] 248s returns a frozen instance 248s on ["A"] with "A" 248s preserves the original 248s returns ["A", "A"] 248s returns a frozen instance 248s on ["A", "B", "C"] with "D" 248s preserves the original 248s returns ["D", "A", "B", "C"] 248s returns a frozen instance 248s 248s Immutable::Hash 248s #all? 248s when empty 248s without a block 248s returns true 248s with a block 248s returns true 248s when not empty 248s without a block 248s returns true 248s with a block 248s returns true if the block always returns true 248s returns false if the block ever returns false 248s propagates an exception from the block 248s stops iterating as soon as the block returns false 248s 248s Immutable::Hash 248s #any? 248s when empty 248s with a block returns false 248s with no block returns false 248s when not empty 248s with a block 248s returns true if the block ever returns true (["A", "aye"]) 248s returns false if the block always returns false 248s returns true if the block ever returns true (["B", "bee"]) 248s returns false if the block always returns false 248s returns true if the block ever returns true (["C", "see"]) 248s returns false if the block always returns false 248s returns true if the block ever returns true ([nil, "NIL"]) 248s returns false if the block always returns false 248s propagates exceptions raised in the block 248s stops iterating as soon as the block returns true 248s with no block 248s returns true 248s 248s Immutable::Hash 248s #assoc 248s searches for a key/val pair with a given key 248s returns nil if a matching key is not found 248s returns nil even if there is a default 248s uses #== to compare keys with provided object 248s #rassoc 248s searches for a key/val pair with a given value 248s returns nil if a matching value is not found 248s returns nil even if there is a default 248s uses #== to compare values with provided object 248s 248s Immutable::Hash 248s #clear 248s maintains the default Proc, if there is one 248s on [] 248s preserves the original 248s returns an empty hash 248s on [{"A"=>"aye"}] 248s preserves the original 248s returns an empty hash 248s on [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 248s preserves the original 248s returns an empty hash 248s on a subclass 248s returns an empty instance of the subclass 248s 248s Immutable::Hash 248s .hash 248s with nothing 248s returns the canonical empty hash 248s with an implicit hash 248s is equivalent to repeatedly using #put 248s with an array of pairs 248s initializes a new Hash 248s with an Immutable::Hash 248s initializes an equivalent Hash 248s 248s Immutable::Hash 248s #dup 248s returns self 248s #clone 248s returns self 248s 248s Immutable::Hash 248s #default_proc 248s returns the default block given when the Hash was created 248s returns nil if no default block was given 248s after a key/val pair are inserted 248s doesn't change 248s after all key/val pairs are filtered out 248s doesn't change 248s after Hash is inverted 248s doesn't change 248s when a slice is taken 248s doesn't change 248s when keys are removed with #except 248s doesn't change 248s when Hash is mapped 248s doesn't change 248s when another Hash is merged in 248s doesn't change 248s 248s Immutable::Hash 248s #delete 248s with an existing key 248s preserves the original 248s returns a copy with the remaining key/value pairs 248s with a non-existing key 248s preserves the original values 248s returns self 248s when removing the last key 248s from a Hash with no default block 248s returns the canonical empty Hash 248s 248s Immutable::Hash 248s #dig 248s returns the value with one argument to dig 248s returns the value in nested hashes 248s returns nil if the key is not present 248s returns nil if you dig out the end of the hash 248s raises a NoMethodError if a value does not support #dig 248s returns the correct value when there is a default proc 248s 248s Immutable::Hash 248s #each 248s with a block (internal iteration) 248s returns self 248s yields all key/value pairs 248s yields key/value pairs in the same order as #each_key and #each_value 248s yields both of a pair of colliding keys 248s yields only the key to a block expecting |key,| 248s with no block 248s returns an Enumerator 248s #each_pair 248s with a block (internal iteration) 248s returns self 248s yields all key/value pairs 248s yields key/value pairs in the same order as #each_key and #each_value 248s yields both of a pair of colliding keys 248s yields only the key to a block expecting |key,| 248s with no block 248s returns an Enumerator 248s #each_key 248s yields all keys 248s with no block 248s returns an Enumerator 248s #each_value 248s yields all values 248s with no block 248s returns an Enumerator 248s 248s Immutable::Hash 248s #each_with_index 248s with a block (internal iteration) 248s returns self 248s yields all key/value pairs with numeric indexes 248s with no block 248s returns an Enumerator 248s 248s Immutable::Hash 248s #empty? 248s returns true for [] 248s returns false for [{"A"=>"aye"}] 248s returns false for [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 248s returns true for empty hashes which have a default block 248s .empty 248s returns the canonical empty Hash 248s from a subclass 248s returns an empty instance of the subclass 248s calls overridden #initialize when creating empty Hash 248s 248s Immutable::Hash 248s returns true on a large hash which is modified and then modified back again 248s #eql? 248s returns false when comparing with a standard hash 248s returns false when comparing with an arbitrary object 248s returns false when comparing with a subclass of Immutable::Hash 248s #== 248s returns true when comparing with a standard hash 248s returns false when comparing with an arbitrary object 248s returns true when comparing with a subclass of Immutable::Hash 248s performs numeric conversions between floats and BigDecimals 248s #eql? 248s returns true 248s for {} and {} 248s for {} and {} 248s returns false 248s for {"A"=>"aye"} and {} 248s for {} and {"A"=>"aye"} 248s returns false 248s for {} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {} 248s returns true 248s for {"A"=>"aye"} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {"A"=>"aye"} 248s returns false 248s for {"A"=>"aye"} and {"B"=>"bee"} 248s for {"B"=>"bee"} and {"A"=>"aye"} 248s returns false 248s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 248s returns false 248s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 248s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 248s returns true 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s returns true 248s for {"C"=>"see", "A"=>"aye", "B"=>"bee"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"C"=>"see", "A"=>"aye", "B"=>"bee"} 248s #== 248s returns true 248s for {} and {} 248s for {} and {} 248s returns false 248s for {"A"=>"aye"} and {} 248s for {} and {"A"=>"aye"} 248s returns false 248s for {} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {} 248s returns true 248s for {"A"=>"aye"} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {"A"=>"aye"} 248s returns false 248s for {"A"=>"aye"} and {"B"=>"bee"} 248s for {"B"=>"bee"} and {"A"=>"aye"} 248s returns false 248s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 248s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 248s returns false 248s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 248s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 248s returns true 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s returns true 248s for {"C"=>"see", "A"=>"aye", "B"=>"bee"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 248s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"C"=>"see", "A"=>"aye", "B"=>"bee"} 248s 248s Immutable::Hash 248s #except 248s works on a large Hash, with many combinations of input 248s with only keys that the Hash has 248s returns a Hash without those values 248s doesn't change the original Hash 248s with keys that the Hash doesn't have 248s returns a Hash without the values that it had keys for 248s doesn't change the original Hash 248s 248s Immutable::Hash 248s #fetch 248s gives precedence to default block over default argument if passed both 248s raises an ArgumentError when not passed one or 2 arguments 248s with no default provided 248s when the key exists 248s returns the value associated with the key 248s when the key does not exist 248s raises a KeyError 248s with a default value 248s when the key exists 248s returns the value associated with the key 248s when the key does not exist 248s returns the default value 248s with a default block 248s when the key exists 248s returns the value associated with the key 248s when the key does not exist 248s invokes the default block with the missing key as paramter 248s 248s Immutable::Hash 248s #fetch_values 248s when the all the requested keys exist 248s returns a vector of values for the given keys 248s when the key does not exist 248s raises a KeyError 248s 248s Immutable::Hash 248s #find 248s stops iterating when the block returns true 248s on [] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns ["A", "aye"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns ["A", "aye"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns ["B", "bee"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns [nil, "NIL"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s #detect 248s stops iterating when the block returns true 248s on [] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns ["A", "aye"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns ["A", "aye"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns ["B", "bee"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns [nil, "NIL"] 248s without a block 248s returns an Enumerator 248s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 248s with a block 248s returns nil 248s without a block 248s returns an Enumerator 248s 248s Immutable::Hash 248s #flat_map 248s yields each key/val pair 248s returns the concatenation of block return values 248s doesn't change the receiver 248s returns an empty array if only empty arrays are returned by block 248s with no block 248s returns an Enumerator 248s 248s Immutable::Hash 248s #flatten 248s with flatten depth of zero 248s returns a vector of keys/value 248s without array keys or values 248s returns a vector of keys and values 248s doesn't modify the receiver 248s on an empty Hash 248s returns an empty Vector 248s with array keys 248s flattens array keys into returned vector if flatten depth is sufficient 248s doesn't modify the receiver (or its contents) 248s with array values 248s flattens array values into returned vector if flatten depth is sufficient 248s doesn't modify the receiver (or its contents) 248s with vector keys 248s flattens vector keys into returned vector if flatten depth is sufficient 248s with vector values 248s flattens vector values into returned vector if flatten depth is sufficient 248s 248s Immutable::Hash 248s #get 248s uses #hash to look up keys 248s uses #eql? to compare keys with the same hash code 248s does not use #eql? to compare keys with different hash codes 248s with a default block 248s when the key exists 248s returns the value associated with the key 248s does not call the default block even if the key is 'nil' 248s when the key does not exist 248s returns the value from the default block 248s with no default block 248s returns the value ("aye") for an existing key ("A") 248s returns the value ("bee") for an existing key ("B") 248s returns the value ("see") for an existing key ("C") 248s returns the value ("NIL") for an existing key (nil) 248s returns nil for a non-existing key 248s #[] 248s uses #hash to look up keys 248s uses #eql? to compare keys with the same hash code 248s does not use #eql? to compare keys with different hash codes 248s with a default block 248s when the key exists 248s returns the value associated with the key 248s does not call the default block even if the key is 'nil' 248s when the key does not exist 248s returns the value from the default block 248s with no default block 248s returns the value ("aye") for an existing key ("A") 248s returns the value ("bee") for an existing key ("B") 248s returns the value ("see") for an existing key ("C") 248s returns the value ("NIL") for an existing key (nil) 248s returns nil for a non-existing key 248s 248s Immutable::Hash 248s #key? 248s returns true for an existing key ("A") 248s returns true for an existing key ("B") 248s returns true for an existing key ("C") 248s returns true for an existing key (nil) 248s returns true for an existing key (2.0) 248s returns false for a non-existing key 248s uses #eql? for equality 248s returns true if the key is found and maps to nil 248s returns true if the key is found and maps to false 248s #has_key? 248s returns true for an existing key ("A") 248s returns true for an existing key ("B") 248s returns true for an existing key ("C") 248s returns true for an existing key (nil) 248s returns true for an existing key (2.0) 248s returns false for a non-existing key 248s uses #eql? for equality 248s returns true if the key is found and maps to nil 248s returns true if the key is found and maps to false 248s #include? 248s returns true for an existing key ("A") 248s returns true for an existing key ("B") 248s returns true for an existing key ("C") 248s returns true for an existing key (nil) 248s returns true for an existing key (2.0) 248s returns false for a non-existing key 248s uses #eql? for equality 248s returns true if the key is found and maps to nil 248s returns true if the key is found and maps to false 248s #member? 248s returns true for an existing key ("A") 248s returns true for an existing key ("B") 248s returns true for an existing key ("C") 248s returns true for an existing key (nil) 248s returns true for an existing key (2.0) 248s returns false for a non-existing key 248s uses #eql? for equality 248s returns true if the key is found and maps to nil 248s returns true if the key is found and maps to false 248s 248s Immutable::Hash 248s #value? 248s returns true if any key/val pair in Hash has the same value 248s returns false if no key/val pair in Hash has the same value 248s uses #== to check equality 248s works on a large hash 248s #has_value? 248s returns true if any key/val pair in Hash has the same value 248s returns false if no key/val pair in Hash has the same value 248s uses #== to check equality 248s works on a large hash 248s 248s Immutable::Hash 248s #hash 248s values are sufficiently distributed 248s differs given the same keys and different values 248s differs given the same values and different keys 248s generates the same hash value for a hash regardless of the order things were added to it 248s on an empty hash 248s returns 0 248s 248s Immutable::Hash 248s #inspect 248s on [] 248s returns "Immutable::Hash[]" 248s on [{"A"=>"aye"}] 248s returns "Immutable::Hash[\"A\" => \"aye\"]" 248s on [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 248s returns "Immutable::Hash[\"A\" => \"aye\", \"B\" => \"bee\", \"C\" => \"see\"]" 248s on {} 248s returns a string which can be eval'd to get an equivalent object 248s on {"A"=>"aye"} 248s returns a string which can be eval'd to get an equivalent object 248s on {:a=>"aye", :b=>"bee", :c=>"see"} 248s returns a string which can be eval'd to get an equivalent object 248s 248s Immutable::Hash 248s #invert 248s uses the existing keys as values and values as keys 248s will select one key/value pair among multiple which have same value 248s doesn't change the original Hash 248s from a subclass of Hash 248s returns an instance of the subclass 248s 248s Immutable::Hash 248s #key 248s returns a key associated with the given value, if there is one 248s returns nil if there is no key associated with the given value 248s uses #== to compare values for equality 248s doesn't use default block if value is not found 248s 248s Immutable::Hash 248s #keys 248s returns the keys as a set 248s returns frozen String keys 248s 248s Immutable::Hash 248s #map 248s when empty 248s returns self 248s when not empty 248s with a block 248s preserves the original values 248s returns a new hash with the mapped values 248s with no block 248s returns an Enumerator 248s from a subclass 248s returns an instance of the subclass 248s #collect 248s when empty 248s returns self 248s when not empty 248s with a block 248s preserves the original values 248s returns a new hash with the mapped values 248s with no block 248s returns an Enumerator 248s from a subclass 248s returns an instance of the subclass 248s 248s Immutable::Hash 248s #marshal_dump/#marshal_load 249s can survive dumping and loading into a new process 249s is still possible to find items by key after loading 249s 249s Immutable::Hash 249s #merge 249s sets any duplicate key to the value of block if passed a block 249s yields key/value pairs in the same order as #each 249s for {} and {} 249s returns {} when passed an Immutable::Hash 249s returns {} when passed a Ruby Hash 249s doesn't change the original Hashes 249s for {"A"=>"aye"} and {} 249s returns {"A"=>"aye"} when passed an Immutable::Hash 249s returns {"A"=>"aye"} when passed a Ruby Hash 249s doesn't change the original Hashes 249s for {"A"=>"aye"} and {"A"=>"bee"} 249s returns {"A"=>"bee"} when passed an Immutable::Hash 249s returns {"A"=>"bee"} when passed a Ruby Hash 249s doesn't change the original Hashes 249s for {"A"=>"aye"} and {"B"=>"bee"} 249s returns {"A"=>"aye", "B"=>"bee"} when passed an Immutable::Hash 249s returns {"A"=>"aye", "B"=>"bee"} when passed a Ruby Hash 249s doesn't change the original Hashes 249s for [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300]] and [[150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] 249s returns [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] when passed an Immutable::Hash 249s returns [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] when passed a Ruby Hash 249s doesn't change the original Hashes 249s when merging with an empty Hash 249s returns self 249s when merging with subset Hash 249s returns self 249s when called on a subclass 249s returns an instance of the subclass 249s 249s Immutable::Hash 249s #min 249s returns the smallest key/val pair 249s #max 249s returns the largest key/val pair 249s #min_by 249s returns the smallest key/val pair (after passing it through a key function) 249s returns the first key/val pair yielded by #each in case of a tie 249s returns nil if the hash is empty 249s #max_by 249s returns the largest key/val pair (after passing it through a key function) 249s returns the first key/val pair yielded by #each in case of a tie 249s returns nil if the hash is empty 249s 249s Immutable::Hash 249s .new 249s is amenable to overriding of #initialize 249s accepts an array as initializer 249s returns a Hash which doesn't change even if initializer is mutated 249s from a subclass 249s returns a frozen instance of the subclass 249s .[] 249s accepts a Ruby Hash as initializer 249s accepts a Immutable::Hash as initializer 249s accepts an array as initializer 249s can be used with a subclass of Immutable::Hash 249s 249s Immutable::Hash 249s #none? 249s when empty 249s with a block returns true 249s with no block returns true 249s when not empty 249s with a block 249s returns false if the block ever returns true (["A", "aye"]) 249s returns true if the block always returns false 249s stops iterating as soon as the block returns true 249s returns false if the block ever returns true (["B", "bee"]) 249s returns true if the block always returns false 249s stops iterating as soon as the block returns true 249s returns false if the block ever returns true (["C", "see"]) 249s returns true if the block always returns false 249s stops iterating as soon as the block returns true 249s returns false if the block ever returns true ([nil, "NIL"]) 249s returns true if the block always returns false 249s stops iterating as soon as the block returns true 249s with no block 249s returns false 249s 249s Immutable::Hash 249s #partition 249s returns a pair of Immutable::Hashes 249s returns key/val pairs for which predicate is true in first Hash 249s returns key/val pairs for which predicate is false in second Hash 249s doesn't modify the original Hash 249s from a subclass 249s should return instances of the subclass 249s 249s Immutable::Hash 249s #pretty_print 249s prints the whole Hash on one line if it fits 249s prints each key/val pair on its own line, if not 249s prints keys and vals on separate lines, if space is very tight 249s 249s Immutable::Hash 249s #[]= 249s raises error pointing to #put 249s #put 249s with a block 249s passes the value to the block 249s replaces the value with the result of the block 249s supports to_proc methods 249s if there is no existing association 249s passes nil to the block 249s stores the result of the block as the new value 249s with a unique key 249s preserves the original 249s returns a copy with the superset of key/value pairs 249s with a duplicate key 249s preserves the original 249s returns a copy with the superset of key/value pairs 249s with duplicate key and identical value 249s returns the original hash unmodified 249s with big hash (force nested tries) 249s returns the original hash unmodified for all changes 249s with unequal keys which hash to the same value 249s stores and can retrieve both 249s when a String is inserted as key and then mutated 249s is not affected 249s 249s Immutable::Hash 249s #reduce 249s when empty 249s returns the memo 249s when not empty 249s with a block 249s returns the final memo 249s with no block 249s uses a passed string as the name of a method to use instead 249s uses a passed symbol as the name of a method to use instead 249s #inject 249s when empty 249s returns the memo 249s when not empty 249s with a block 249s returns the final memo 249s with no block 249s uses a passed string as the name of a method to use instead 249s uses a passed symbol as the name of a method to use instead 249s 249s Immutable::Hash 249s #reject 249s when nothing matches 249s returns self 249s when only some things match 249s with a block 249s preserves the original 249s returns a set with the matching values 249s yields entries in the same order as #each 249s with no block 249s returns an Enumerator 249s on a large hash, with many combinations of input 249s still works 249s #delete_if 249s when nothing matches 249s returns self 249s when only some things match 249s with a block 249s preserves the original 249s returns a set with the matching values 249s yields entries in the same order as #each 249s with no block 249s returns an Enumerator 249s on a large hash, with many combinations of input 249s still works 249s 249s Immutable::Hash 249s #reverse_each 249s with a block 249s returns self 249s yields all key/value pairs in the opposite order as #each 249s with no block 249s returns an Enumerator 249s 249s Immutable::Hash 249s #sample 249s returns a randomly chosen item 249s 249s Immutable::Hash 249s #select 250s works on a large hash, with many combinations of input 250s when everything matches 250s returns self 250s when only some things match 250s yields entries as [key, value] pairs 250s with a block 250s preserves the original 250s returns a set with the matching values 250s with no block 250s returns an Enumerator 250s #find_all 250s works on a large hash, with many combinations of input 250s when everything matches 250s returns self 250s when only some things match 250s yields entries as [key, value] pairs 250s with a block 250s preserves the original 250s returns a set with the matching values 250s with no block 250s returns an Enumerator 250s #keep_if 250s works on a large hash, with many combinations of input 250s when everything matches 250s returns self 250s when only some things match 250s yields entries as [key, value] pairs 250s with a block 250s preserves the original 250s returns a set with the matching values 250s with no block 250s returns an Enumerator 250s 250s Immutable::Hash 250s #size 250s returns 0 for [] 250s returns 1 for [{"A"=>"aye"}] 250s returns 3 for [{"A"=>"bee", "B"=>"bee", "C"=>"see"}] 250s has the correct size after adding lots of things with colliding keys and such 251s has the correct size after lots of addings and removings 251s #length 251s returns 0 for [] 251s returns 1 for [{"A"=>"aye"}] 251s returns 3 for [{"A"=>"bee", "B"=>"bee", "C"=>"see"}] 251s has the correct size after adding lots of things with colliding keys and such 251s has the correct size after lots of addings and removings 251s 251s Immutable::Hash 251s #slice 251s with all keys present in the Hash 251s returns the sliced values 251s doesn't modify the original Hash 251s with keys aren't present in the Hash 251s returns the sliced values of the matching keys 251s doesn't modify the original Hash 251s on a Hash with a default block 251s maintains the default block 251s 251s Immutable::Hash 251s #sort 251s returns a Vector of sorted key/val pairs 251s works on large hashes 251s uses block as comparator to sort if passed a block 251s #sort_by 251s returns a Vector of key/val pairs, sorted using the block as a key function 251s 251s Immutable::Hash 251s #store 251s with a unique key 251s preserves the original 251s returns a copy with the superset of key/value pairs 251s with a duplicate key 251s preserves the original 251s returns a copy with the superset of key/value pairs 251s with duplicate key and identical value 251s returns the original hash unmodified 251s with big hash (force nested tries) 251s returns the original hash unmodified for all changes 251s with unequal keys which hash to the same value 251s stores and can retrieve both 251s when a String is inserted as key and then mutated 251s is not affected 251s 251s Immutable::Hash 251s #<= 251s for {} and {} 251s returns true 251s for {"A"=>1} and {} 251s returns false 251s for {} and {"A"=>1} 251s returns true 251s for {"A"=>1} and {"A"=>1} 251s returns true 251s for {"A"=>1} and {"A"=>2} 251s returns false 251s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 251s returns true 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 251s returns false 251s for {"B"=>0} and {"A"=>1, "B"=>2, "C"=>3} 251s returns false 251s #< 251s for {} and {} 251s returns false 251s for {"A"=>1} and {} 251s returns false 251s for {} and {"A"=>1} 251s returns true 251s for {"A"=>1} and {"A"=>1} 251s returns false 251s for {"A"=>1} and {"A"=>2} 251s returns false 251s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 251s returns true 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 251s returns false 251s for {"B"=>0} and {"A"=>1, "B"=>2, "C"=>3} 251s returns false 251s 251s Immutable::Hash 251s #>= 251s for {} and {} 251s returns true 251s for {"A"=>1} and {} 251s returns true 251s for {} and {"A"=>1} 251s returns false 251s for {"A"=>1} and {"A"=>1} 251s returns true 251s for {"A"=>1} and {"A"=>2} 251s returns false 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 251s returns true 251s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 251s returns false 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>0} 251s returns false 251s #> 251s for {} and {} 251s returns false 251s for {"A"=>1} and {} 251s returns true 251s for {} and {"A"=>1} 251s returns false 251s for {"A"=>1} and {"A"=>1} 251s returns false 251s for {"A"=>1} and {"A"=>2} 251s returns false 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 251s returns true 251s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 251s returns false 251s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>0} 251s returns false 251s 251s Immutable::Hash 251s #take 251s returns the first N key/val pairs from hash 251s #take_while 251s passes elements to the block until the block returns nil/false 251s returns an array of all elements before the one which returned nil/false 251s passes all elements if the block never returns nil/false 251s 251s Immutable::Hash 251s #to_a 251s returns an Array of [key, value] pairs in same order as #each 251s 251s Immutable::Hash 251s #to_hash 251s converts an empty Immutable::Hash to an empty Ruby Hash 251s converts a non-empty Immutable::Hash to a Hash with the same keys and values 251s doesn't modify the receiver 251s #to_h 251s converts an empty Immutable::Hash to an empty Ruby Hash 251s converts a non-empty Immutable::Hash to a Hash with the same keys and values 251s doesn't modify the receiver 251s 251s Immutable::Hash 251s #to_proc 251s on Hash without default proc 251s returns a Proc instance 251s returns a Proc that returns the value of an existing key 251s returns a Proc that returns nil for a missing key 251s on Hash with a default proc 251s returns a Proc instance 251s returns a Proc that returns the value of an existing key 251s returns a Proc that returns the result of the hash's default proc for a missing key 251s 251s Immutable::Hash 251s #update_in 251s with one level on existing key 251s passes the value to the block 251s replaces the value with the result of the block 251s should preserve the original 251s with multi-level on existing keys 251s passes the value to the block 251s replaces the value with the result of the block 251s should preserve the original 251s with multi-level creating sub-hashes when keys don't exist 251s passes nil to the block 251s creates subhashes on the way to set the value 251s with multi-level including vector with existing keys 251s passes the value to the block 251s replaces the value with the result of the block 251s should preserve the original 251s with empty key_path 251s raises ArguemntError 251s 251s Immutable::Hash 251s #values_at 251s on Hash without default proc 251s returns an empty vector when no keys are given 251s returns a vector of values for the given keys 251s fills nil when keys are missing 251s on Hash with default proc 251s fills the result of the default proc when keys are missing 251s 251s Immutable::Hash 251s #values 251s returns the keys as a Vector 251s with duplicates 251s returns the keys as a Vector 251s 251s Immutable::List 251s #add 251s on [] with "A" 251s preserves the original 251s returns ["A"] 251s on ["A"] with "B" 251s preserves the original 251s returns ["B", "A"] 251s on ["A"] with "A" 251s preserves the original 251s returns ["A", "A"] 251s on ["A", "B", "C"] with "D" 251s preserves the original 251s returns ["D", "A", "B", "C"] 251s 251s Immutable::List 251s #all? 251s on a really big list 251s doesn't run out of stack 251s when empty 251s with a block returns true 251s with no block returns true 251s when not empty 251s with a block 251s if the block always returns true 251s returns true 251s if the block ever returns false 251s returns false 251s with no block 251s if all values are truthy 251s returns true 251s if any value is nil 251s returns false 251s if any value is false 251s returns false 251s 251s Immutable::List 251s #any? 251s on a really big list 251s doesn't run out of stack 251s when empty 251s with a block returns false 251s with no block returns false 251s when not empty 251s with a block 252s returns true if the block ever returns true ("A") 252s returns true if the block ever returns true ("B") 252s returns true if the block ever returns true ("C") 252s returns true if the block ever returns true (nil) 252s returns false if the block always returns false 252s with no block 252s returns true if any value is truthy 252s returns false if all values are falsey 252s 252s Immutable::List 252s #append 252s is lazy 252s on [] and [] 252s preserves the left 252s preserves the right 252s returns [] 252s on ["A"] and [] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on [] and ["A"] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on ["A", "B"] and ["C", "D"] 252s preserves the left 252s preserves the right 252s returns ["A", "B", "C", "D"] 252s #concat 252s is lazy 252s on [] and [] 252s preserves the left 252s preserves the right 252s returns [] 252s on ["A"] and [] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on [] and ["A"] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on ["A", "B"] and ["C", "D"] 252s preserves the left 252s preserves the right 252s returns ["A", "B", "C", "D"] 252s #+ 252s is lazy 252s on [] and [] 252s preserves the left 252s preserves the right 252s returns [] 252s on ["A"] and [] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on [] and ["A"] 252s preserves the left 252s preserves the right 252s returns ["A"] 252s on ["A", "B"] and ["C", "D"] 252s preserves the left 252s preserves the right 252s returns ["A", "B", "C", "D"] 252s 252s Immutable::List 252s #at 252s on a really big list 252s doesn't run out of stack 252s [] with 10 252s returns nil 252s ["A"] with 10 252s returns nil 252s ["A", "B", "C"] with 0 252s returns "A" 252s ["A", "B", "C"] with 2 252s returns "C" 252s ["A", "B", "C"] with -1 252s returns "C" 252s ["A", "B", "C"] with -2 252s returns "B" 252s ["A", "B", "C"] with -4 252s returns nil 252s 252s Immutable::List 252s #break 252s is lazy 252s on [] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [1] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [1, 2] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [1, 2, 3] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [1, 2, 3, 4] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [2, 3, 4] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [3, 4] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s on [4] 252s with a block 252s preserves the original 252s returns a frozen array with two items 252s correctly identifies the prefix 252s correctly identifies the remainder 252s without a block 252s returns a frozen array with two items 252s returns self as the prefix 252s leaves the remainder empty 252s 252s Immutable::List 252s #car 252s is responded to 252s on [] 252s preserves the original 252s returns nil 252s #car 252s is responded to 252s on ["A"] 252s preserves the original 252s returns "A" 252s #car 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns "A" 252s #cadr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns "B" 252s #caddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns "C" 252s #cadddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns nil 252s #caddddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns nil 252s #cdr 252s is responded to 252s on [] 252s preserves the original 252s returns Immutable::List[] 252s #cdr 252s is responded to 252s on ["A"] 252s preserves the original 252s returns Immutable::List[] 252s #cdr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns Immutable::List["B", "C"] 252s #cddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns Immutable::List["C"] 252s #cdddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns Immutable::List[] 252s #cddddr 252s is responded to 252s on ["A", "B", "C"] 252s preserves the original 252s returns Immutable::List[] 252s 252s Immutable::List 252s #chunk 252s is lazy 252s on [] 252s preserves the original 252s returns [] 252s on ["A"] 252s preserves the original 252s returns [Immutable::List["A"]] 252s on ["A", "B", "C"] 252s preserves the original 252s returns [Immutable::List["A", "B"], Immutable::List["C"]] 252s 252s Immutable::List 252s #clear 252s on [] 252s preserves the original 252s returns an empty list 252s on ["A"] 252s preserves the original 252s returns an empty list 252s on ["A", "B", "C"] 252s preserves the original 252s returns an empty list 252s 252s Immutable::List 252s #combination 252s is lazy 252s on ["A", "B", "C", "D"] in groups of 1 252s preserves the original 252s returns [Immutable::List["A"], Immutable::List["B"], Immutable::List["C"], Immutable::List["D"]] 252s on ["A", "B", "C", "D"] in groups of 2 252s preserves the original 252s returns [Immutable::List["A", "B"], Immutable::List["A", "C"], Immutable::List["A", "D"], Immutable::List["B", "C"], Immutable::List["B", "D"], Immutable::List["C", "D"]] 252s on ["A", "B", "C", "D"] in groups of 3 252s preserves the original 252s returns [Immutable::List["A", "B", "C"], Immutable::List["A", "B", "D"], Immutable::List["A", "C", "D"], Immutable::List["B", "C", "D"]] 252s on ["A", "B", "C", "D"] in groups of 4 252s preserves the original 252s returns [Immutable::List["A", "B", "C", "D"]] 252s on ["A", "B", "C", "D"] in groups of 0 252s preserves the original 252s returns [Immutable::List[]] 252s on ["A", "B", "C", "D"] in groups of 5 252s preserves the original 252s returns [] 252s on [] in groups of 0 252s preserves the original 252s returns [Immutable::List[]] 252s on [] in groups of 1 252s preserves the original 252s returns [] 252s 252s Immutable::List 252s #compact 252s is lazy 252s on [] 252s preserves the original 252s returns [] 252s on ["A"] 252s preserves the original 252s returns ["A"] 252s on ["A", "B", "C"] 252s preserves the original 252s returns ["A", "B", "C"] 252s on [nil] 252s preserves the original 252s returns [] 252s on [nil, "B"] 252s preserves the original 252s returns ["B"] 252s on ["A", nil] 252s preserves the original 252s returns ["A"] 252s on [nil, nil] 252s preserves the original 252s returns [] 252s on ["A", nil, "C"] 252s preserves the original 252s returns ["A", "C"] 252s on [nil, "B", nil] 252s preserves the original 252s returns ["B"] 252s 252s Immutable::List 252s #<=> 252s with [] and [1] 252s returns -1 252s with [1] and [] 252s returns 1 252s with [] and [] 252s returns 0 252s with [1] and [2] 252s returns -1 252s with [2] and [1] 252s returns 1 252s with [1] and [1] 252s returns 0 252s with [1] and [1, 2] 252s returns -1 252s with [1, 2] and [1] 252s returns 1 252s with [1] and [1] 252s returns 0 252s with [2, 3, 4] and [3, 4, 5] 252s returns -1 252s with [3, 4, 5] and [2, 3, 4] 252s returns 1 252s with [2, 3, 4] and [2, 3, 4] 252s returns 0 252s 252s Immutable::List 252s #cons 252s on [] with "A" 252s preserves the original 252s returns ["A"] 252s on ["A"] with "B" 252s preserves the original 252s returns ["B", "A"] 252s on ["A"] with "A" 252s preserves the original 252s returns ["A", "A"] 252s on ["A", "B", "C"] with "D" 252s preserves the original 252s returns ["D", "A", "B", "C"] 252s 252s Immutable 252s .list 252s with no arguments 252s always returns the same instance 252s returns an empty list 252s with a number of items 252s always returns a different instance 252s is the same as repeatedly using #cons 252s .stream 252s with no block 252s returns an empty list 252s with a block 252s repeatedly calls the block 252s .interval 252s for numbers 252s is equivalent to a list with explicit values 252s for strings 252s is equivalent to a list with explicit values 252s .repeat 252s returns an infinite list with specified value for each element 252s .replicate 252s returns a list with the specified value repeated the specified number of times 252s .iterate 252s returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on 252s .enumerate 252s returns a list based on the values yielded from the enumerator 252s realizes values as they are needed 252s [] 252s takes a variable number of items and returns a list 252s returns an empty list when called without arguments 252s 252s Immutable::List 252s on [] 252s returns self 252s on ["A"] 252s returns self 252s on ["A", "B", "C"] 252s returns self 252s on [] 252s returns self 252s on ["A"] 252s returns self 252s on ["A", "B", "C"] 252s returns self 252s 252s Immutable::List 252s #count 252s on a really big list 252s doesn't run out of stack 252s on [] 252s with a block 252s returns 0 252s without a block 252s returns length 252s on [1] 252s with a block 252s returns 1 252s without a block 252s returns length 252s on [1, 2] 252s with a block 252s returns 1 252s without a block 252s returns length 252s on [1, 2, 3] 252s with a block 252s returns 2 252s without a block 252s returns length 252s on [1, 2, 3, 4] 252s with a block 252s returns 2 252s without a block 252s returns length 252s on [1, 2, 3, 4, 5] 252s with a block 252s returns 3 252s without a block 252s returns length 252s 252s Immutable 252s #cycle 252s is lazy 252s with an empty list 252s returns an empty list 252s with a non-empty list 252s preserves the original 252s infinitely cycles through all values 252s 252s Immutable::List 252s #delete_at 252s removes the element at the specified index 252s makes no modification if the index is out of range 252s 252s Immutable::List 252s #delete 252s removes elements that are #== to the argument 252s 252s Immutable::List 252s #drop 252s is lazy 252s with 10 from [] 252s preserves the original 252s returns [] 252s with 10 from ["A"] 252s preserves the original 252s returns [] 252s with -1 from ["A"] 252s preserves the original 252s returns ["A"] 252s with 0 from ["A", "B", "C"] 252s preserves the original 252s returns ["A", "B", "C"] 252s with 2 from ["A", "B", "C"] 252s preserves the original 252s returns ["C"] 252s 252s Immutable::List 252s #drop_while 252s is lazy 252s on [] 252s with a block 252s preserves the original 252s returns [] 252s without a block 252s returns an Enumerator 252s on ["A"] 252s with a block 252s preserves the original 252s returns [] 252s without a block 252s returns an Enumerator 252s on ["A", "B", "C"] 252s with a block 252s preserves the original 252s returns ["C"] 252s without a block 252s returns an Enumerator 252s 252s Immutable::List 252s #each_chunk 252s on a really big list 253s doesn't run out of stack 253s on [] 253s with a block 253s preserves the original 253s iterates over the items in order 253s returns self 253s without a block 253s preserves the original 253s returns an Enumerator 253s on ["A"] 253s with a block 253s preserves the original 253s iterates over the items in order 253s returns self 253s without a block 253s preserves the original 253s returns an Enumerator 253s on ["A", "B", "C"] 253s with a block 253s preserves the original 253s iterates over the items in order 253s returns self 253s without a block 253s preserves the original 253s returns an Enumerator 253s #each_slice 253s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s on ["A"] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s on ["A", "B", "C"] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s 254s Immutable::List 254s #each 254s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s iterates over the items in order 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s iterates over the items in order 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A", "B", "C"] 254s with a block 254s iterates over the items in order 254s returns nil 254s without a block 254s returns an Enumerator 254s 254s Immutable::List 254s #each_with_index 254s with no block 254s returns an Enumerator 254s with a block 254s returns self 254s iterates over the items in order, yielding item and index 254s 254s Immutable::List 254s #empty? 254s on a really big list 254s doesn't run out of stack 254s on [] 254s returns true 254s on ["A"] 254s returns false 254s on ["A", "B", "C"] 254s returns false 254s 254s Immutable::List 254s Immutable::List["A", "B", "C"] should == ["A", "B", "C"] 254s Immutable::List["A", "B", "C"] should not eql? ["A", "B", "C"] 254s Immutable::List["A", "B", "C"] should not == # 254s Immutable::List["A", "B", "C"] should not eql? # 254s Immutable::List[] should == [] 254s Immutable::List[] should not eql? [] 254s Immutable::List[] should eql? Immutable::List[] 254s Immutable::List[] should == Immutable::List[] 254s Immutable::List[] should not eql? Immutable::List[nil] 254s Immutable::List["A"] should not eql? Immutable::List[] 254s Immutable::List["A"] should eql? Immutable::List["A"] 254s Immutable::List["A"] should == Immutable::List["A"] 254s Immutable::List["A"] should not eql? Immutable::List["B"] 254s Immutable::List["A", "B"] should not eql? Immutable::List["A"] 254s Immutable::List["A", "B", "C"] should eql? Immutable::List["A", "B", "C"] 254s Immutable::List["A", "B", "C"] should == Immutable::List["A", "B", "C"] 254s Immutable::List["C", "A", "B"] should not eql? Immutable::List["A", "B", "C"] 254s Immutable::List["A"] should == ["A"] 254s ["A"] should == Immutable::List["A"] 254s Immutable::List["A"] should not eql? ["A"] 254s ["A"] should not eql? Immutable::List["A"] 254s #eql? 254s on a really big list 254s doesn't run out of stack 254s 254s Immutable::List 254s #fill 254s can replace a range of items at the beginning of a list 254s can replace a range of items in the middle of a list 254s can replace a range of items at the end of a list 254s can replace all the items in a list 254s can fill past the end of the list 254s is lazy 254s with 1 argument 254s replaces all the items in the list by default 254s with 2 arguments 254s replaces up to the end of the list by default 254s when index and length are 0 254s leaves the list unmodified 254s 254s Immutable::List 254s #find_all 254s is lazy 254s with an empty array 254s with a block 254s preserves the original 254s returns the found list 254s without a block 254s returns an Enumerator 254s with a single item array 254s with a block 254s preserves the original 254s returns the found list 254s without a block 254s returns an Enumerator 254s with a multi-item array 254s with a block 254s preserves the original 254s returns the found list 254s without a block 254s returns an Enumerator 254s with a multi-item single find_allable array 254s with a block 254s preserves the original 254s returns the found list 254s without a block 254s returns an Enumerator 254s with a multi-item multi-find_allable array 254s with a block 254s preserves the original 254s returns the found list 254s without a block 254s returns an Enumerator 254s 254s Immutable::List 254s #find_index 254s on a really big list 254s doesn't run out of stack 254s looking for "A" in [] 254s returns nil 254s looking for nil in [] 254s returns nil 254s looking for "A" in ["A"] 254s returns 0 254s looking for "B" in ["A"] 254s returns nil 254s looking for nil in ["A"] 254s returns nil 254s looking for "A" in ["A", "B", nil] 254s returns 0 254s looking for "B" in ["A", "B", nil] 254s returns 1 254s looking for nil in ["A", "B", nil] 254s returns 2 254s looking for "C" in ["A", "B", nil] 254s returns nil 254s looking for 2 in [2] 254s returns 0 254s looking for 2.0 in [2] 254s returns 0 254s looking for 2.0 in [2.0] 254s returns 0 254s looking for 2 in [2.0] 254s returns 0 254s #index 254s on a really big list 254s doesn't run out of stack 254s looking for "A" in [] 254s returns nil 254s looking for nil in [] 254s returns nil 254s looking for "A" in ["A"] 254s returns 0 254s looking for "B" in ["A"] 254s returns nil 254s looking for nil in ["A"] 254s returns nil 254s looking for "A" in ["A", "B", nil] 254s returns 0 254s looking for "B" in ["A", "B", nil] 254s returns 1 254s looking for nil in ["A", "B", nil] 254s returns 2 254s looking for "C" in ["A", "B", nil] 254s returns nil 254s looking for 2 in [2] 254s returns 0 254s looking for 2.0 in [2] 254s returns 0 254s looking for 2.0 in [2.0] 254s returns 0 254s looking for 2 in [2.0] 254s returns 0 254s 254s Immutable::List 254s #find 254s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on [] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns "A" 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns "A" 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns "B" 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s #detect 254s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on [] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns "A" 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns "A" 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns "B" 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s on ["A", "B", nil] 254s with a block 254s returns nil 254s without a block 254s returns an Enumerator 254s 254s Immutable::List 254s #flat_map 254s with an empty list 254s returns the flattened values as a Immutable::List 254s returns a Immutable::List 254s with a block that returns an empty list 254s returns the flattened values as a Immutable::List 254s returns a Immutable::List 254s with a list of one item 254s returns the flattened values as a Immutable::List 254s returns a Immutable::List 254s with a list of multiple items 254s returns the flattened values as a Immutable::List 254s returns a Immutable::List 254s 254s Immutable 254s #flatten 254s is lazy 254s on [] 254s preserves the original 254s returns an empty list 254s on ["A"] 254s preserves the original 254s returns an empty list 254s on ["A", "B", "C"] 254s preserves the original 254s returns an empty list 254s on ["A", Immutable::List["B"], "C"] 254s preserves the original 254s returns an empty list 254s on [Immutable::List["A"], Immutable::List["B"], Immutable::List["C"]] 254s preserves the original 254s returns an empty list 254s 254s Immutable::List 254s #grep 254s is lazy 254s without a block 254s on [] 254s returns [] 254s on ["A"] 254s returns ["A"] 254s on [1] 254s returns [] 254s on ["A", 2, "C"] 254s returns ["A", "C"] 254s with a block 254s on [] 254s preserves the original 254s returns [] 254s on ["A"] 254s preserves the original 254s returns ["a"] 254s on [1] 254s preserves the original 254s returns [] 254s on ["A", 2, "C"] 254s preserves the original 254s returns ["a", "c"] 254s 254s Immutable::List 254s #group_by 254s on a really big list 254s doesn't run out of stack 254s with a block 254s on [] 254s returns [] 254s on [1] 254s returns [{true=>Immutable::List[1]}] 254s on [1, 2, 3, 4] 254s returns [{true=>Immutable::List[3, 1], false=>Immutable::List[4, 2]}] 254s without a block 254s on [] 254s returns [] 254s on [1] 254s returns [{1=>Immutable::List[1]}] 254s on [1, 2, 3, 4] 254s returns [{1=>Immutable::List[1], 2=>Immutable::List[2], 3=>Immutable::List[3], 4=>Immutable::List[4]}] 254s #group 254s on a really big list 254s doesn't run out of stack 254s with a block 254s on [] 254s returns [] 254s on [1] 254s returns [{true=>Immutable::List[1]}] 254s on [1, 2, 3, 4] 254s returns [{true=>Immutable::List[3, 1], false=>Immutable::List[4, 2]}] 254s without a block 254s on [] 254s returns [] 254s on [1] 254s returns [{1=>Immutable::List[1]}] 254s on [1, 2, 3, 4] 254s returns [{1=>Immutable::List[1], 2=>Immutable::List[2], 3=>Immutable::List[3], 4=>Immutable::List[4]}] 254s 254s Immutable::List 254s #hash 254s values are sufficiently distributed 254s on a really big list 255s doesn't run out of stack 255s on an empty list 255s returns 0 255s 255s Immutable::List 255s #head 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["A", "B", "C"] 255s returns "A" 255s #first 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["A", "B", "C"] 255s returns "A" 255s 255s Immutable::List 255s #include? 255s on a really big list 255s doesn't run out of stack 255s on [] 255s returns false 255s on [] 255s returns false 255s on ["A"] 255s returns true 255s on ["A"] 255s returns false 255s on ["A"] 255s returns false 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns false 255s on [2] 255s returns true 255s on [2] 255s returns true 255s on [2.0] 255s returns true 255s on [2.0] 255s returns true 255s #member? 255s on a really big list 255s doesn't run out of stack 255s on [] 255s returns false 255s on [] 255s returns false 255s on ["A"] 255s returns true 255s on ["A"] 255s returns false 255s on ["A"] 255s returns false 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns true 255s on ["A", "B", nil] 255s returns false 255s on [2] 255s returns true 255s on [2] 255s returns true 255s on [2.0] 255s returns true 255s on [2.0] 255s returns true 255s 255s Immutable::List 255s #index 255s on a really big list 255s doesn't run out of stack 255s looking for "A" in [] 255s returns nil 255s looking for nil in [] 255s returns nil 255s looking for "A" in ["A"] 255s returns 0 255s looking for "B" in ["A"] 255s returns nil 255s looking for nil in ["A"] 255s returns nil 255s looking for "A" in ["A", "B", nil] 255s returns 0 255s looking for "B" in ["A", "B", nil] 255s returns 1 255s looking for nil in ["A", "B", nil] 255s returns 2 255s looking for "C" in ["A", "B", nil] 255s returns nil 255s looking for 2 in [2] 255s returns 0 255s looking for 2.0 in [2] 255s returns 0 255s looking for 2.0 in [2.0] 255s returns 0 255s looking for 2 in [2.0] 255s returns 0 255s 255s Immutable::List 255s #indices 255s when called with a block 255s is lazy 255s on a large list which doesn't contain desired item 255s doesn't blow the stack 255s looking for "A" in [] 255s returns [] 255s looking for "B" in ["A"] 255s returns [] 255s looking for "B" in ["A", "B", "A"] 255s returns [1] 255s looking for "A" in ["A", "B", "A"] 255s returns [0, 2] 255s looking for 2 in [2] 255s returns [0] 255s looking for 2.0 in [2] 255s returns [0] 255s looking for 2.0 in [2.0] 255s returns [0] 255s looking for 2 in [2.0] 255s returns [0] 255s when called with a single argument 255s is lazy 255s looking for "A" in [] 255s returns [] 255s looking for "B" in ["A"] 255s returns [] 255s looking for "B" in ["A", "B", "A"] 255s returns [1] 255s looking for "A" in ["A", "B", "A"] 255s returns [0, 2] 255s looking for 2 in [2] 255s returns [0] 255s looking for 2.0 in [2] 255s returns [0] 255s looking for 2.0 in [2.0] 255s returns [0] 255s looking for 2 in [2.0] 255s returns [0] 255s 255s Immutable::List 255s #init 255s is lazy 255s on [] 255s preserves the original 255s returns the list without the last element: [] 255s on ["A"] 255s preserves the original 255s returns the list without the last element: [] 255s on ["A", "B", "C"] 255s preserves the original 255s returns the list without the last element: ["A", "B"] 255s 255s Immutable::List 255s #inits 255s is lazy 255s on [] 255s preserves the original 255s returns [] 255s on ["A"] 255s preserves the original 255s returns [Immutable::List["A"]] 255s on ["A", "B", "C"] 255s preserves the original 255s returns [Immutable::List["A"], Immutable::List["A", "B"], Immutable::List["A", "B", "C"]] 255s 255s Immutable::List 255s #insert 255s can add items at the beginning of a list 255s can add items in the middle of a list 255s can add items at the end of a list 255s can add items past the end of a list 255s accepts a negative index, which counts back from the end of the list 255s raises IndexError if a negative index is too great 255s is lazy 255s 255s Immutable::List 255s #inspect 255s on a really big list 255s doesn't run out of stack 255s on [] 255s returns "Immutable::List[]" 255s returns a string which can be eval'd to get an equivalent object 255s on ["A"] 255s returns "Immutable::List[\"A\"]" 255s returns a string which can be eval'd to get an equivalent object 255s on ["A", "B", "C"] 255s returns "Immutable::List[\"A\", \"B\", \"C\"]" 255s returns a string which can be eval'd to get an equivalent object 255s 255s Immutable::List 255s #intersperse 255s is lazy 255s on [] 255s preserves the original 255s returns [] 255s on ["A"] 255s preserves the original 255s returns ["A"] 255s on ["A", "B", "C"] 255s preserves the original 255s returns ["A", "|", "B", "|", "C"] 255s 255s Immutable::List 255s #join 255s on a really big list 255s doesn't run out of stack 255s with a separator 255s on [] 255s preserves the original 255s returns "" 255s on ["A"] 255s preserves the original 255s returns "A" 255s on ["A", "B", "C"] 255s preserves the original 255s returns "A|B|C" 255s without a separator 255s on [] 255s preserves the original 255s returns "" 255s on ["A"] 255s preserves the original 255s returns "A" 255s on ["A", "B", "C"] 255s preserves the original 255s returns "ABC" 255s without a separator (with global default separator set) 255s uses the default global separator 255s 255s Immutable::List 255s #last 255s on a really big list 255s doesn't run out of stack 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["A", "B", "C"] 255s returns "C" 255s 255s Immutable::List 255s #<< 255s adds an item onto the end of a list 255s on an empty list 255s returns a list with one item 255s 255s Immutable::List 255s #map 255s is lazy 255s on [] 255s with a block 255s preserves the original 255s returns [] 255s is lazy 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s preserves the original 255s returns ["a"] 255s is lazy 255s without a block 255s returns an Enumerator 255s on ["A", "B", "C"] 255s with a block 255s preserves the original 255s returns ["a", "b", "c"] 255s is lazy 255s without a block 255s returns an Enumerator 255s #collect 255s is lazy 255s on [] 255s with a block 255s preserves the original 255s returns [] 255s is lazy 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s preserves the original 255s returns ["a"] 255s is lazy 255s without a block 255s returns an Enumerator 255s on ["A", "B", "C"] 255s with a block 255s preserves the original 255s returns ["a", "b", "c"] 255s is lazy 255s without a block 255s returns an Enumerator 255s 255s Immutable::List 255s #max 255s on a really big list 255s doesn't run out of stack 255s with a block 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["Ichi", "Ni", "San"] 255s returns "Ichi" 255s without a block 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["Ichi", "Ni", "San"] 255s returns "San" 255s 255s Immutable::List 255s without a comparator 255s on an empty list 255s returns an empty list 255s on a single list 255s returns the list 255s with multiple lists 255s merges the lists based on natural sort order 255s with a comparator 255s on an empty list 255s returns an empty list 255s on a single list 255s returns the list 255s with multiple lists 255s merges the lists based on the specified transformer 255s 255s Immutable::List 255s without a comparator 255s on an empty list 255s returns an empty list 255s on a single list 255s returns the list 255s with multiple lists 255s merges the lists based on natural sort order 255s with a comparator 255s on an empty list 255s returns an empty list 255s on a single list 255s returns the list 255s with multiple lists 255s merges the lists based on the specified comparator 255s 255s Immutable::List 255s #min 255s on a really big list 255s doesn't run out of stack 255s with a block 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["Ichi", "Ni", "San"] 255s returns "Ni" 255s without a block 255s on [] 255s returns nil 255s on ["A"] 255s returns "A" 255s on ["Ichi", "Ni", "San"] 255s returns "Ichi" 255s 255s Immutable::List 255s ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads 255s doesn't go into an infinite loop if lazy list block raises an exception 256s doesn't give horrendously bad performance if thread realizing the list sleeps 256s 256s Immutable::List 256s #none? 256s on a really big list 256s doesn't run out of stack 256s when empty 256s with a block returns true 256s with no block returns true 256s when not empty 256s with a block 256s returns false if the block ever returns true ("A") 256s returns false if the block ever returns true ("B") 256s returns false if the block ever returns true ("C") 256s returns false if the block ever returns true (nil) 256s returns true if the block always returns false 256s with no block 256s returns false if any value is truthy 256s returns true if all values are falsey 256s 256s Immutable::List 256s #one? 256s on a really big list 256s doesn't run out of stack 256s when empty 256s with a block returns false 256s with no block returns false 256s when not empty 256s with a block 256s returns false if the block returns true more than once 256s returns false if the block never returns true 256s returns true if the block only returns true once 256s with no block 256s returns false if more than one value is truthy 256s returns true if only one value is truthy 256s 256s Immutable::List 256s #partition 256s is lazy 256s calls the passed block only once for each item 256s returns a lazy list of items for which predicate is true 256s returns a lazy list of items for which predicate is false 256s calls the passed block only once for each item, even with multiple threads 256s on [] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [1] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [1, 2] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [1, 2, 3] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [1, 2, 3, 4] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [2, 3, 4] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [3, 4] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s on [4] 256s with a block 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s without a block 256s returns an Enumerator 256s 256s Immutable::List 256s #permutation 256s with no block 256s returns an Enumerator 256s with no argument 256s yields all permutations of the list 256s with a length argument 256s yields all N-size permutations of the list 256s with a length argument greater than length of list 256s yields nothing 256s with a length argument of 0 256s yields an empty list 256s with a block 256s returns the original list 256s 256s Immutable::List 256s #pop 256s with an empty list 256s returns an empty list 256s with a list with a few items 256s removes the last item 256s 256s Immutable::List 256s #product 256s on a really big list 256s doesn't run out of stack 256s on [] 256s returns 1 256s on [2] 256s returns 2 256s on [1, 3, 5, 7, 11] 256s returns 1155 256s 256s Immutable::List 256s #reduce 256s on a really big list 256s doesn't run out of stack 256s on [] 256s with an initial value of 10 and a block 256s returns 10 256s on [1] 256s with an initial value of 10 and a block 256s returns 9 256s on [1, 2, 3] 256s with an initial value of 10 and a block 256s returns 4 256s on [] 256s with no initial value and a block 256s returns nil 256s on [1] 256s with no initial value and a block 256s returns 1 256s on [1, 2, 3] 256s with no initial value and a block 256s returns -4 256s with no block and a symbol argument 256s uses the symbol as the name of a method to reduce with 256s with no block and a string argument 256s uses the string as the name of a method to reduce with 256s #inject 256s on a really big list 256s doesn't run out of stack 256s on [] 256s with an initial value of 10 and a block 256s returns 10 256s on [1] 256s with an initial value of 10 and a block 256s returns 9 256s on [1, 2, 3] 256s with an initial value of 10 and a block 256s returns 4 256s on [] 256s with no initial value and a block 256s returns nil 256s on [1] 256s with no initial value and a block 256s returns 1 256s on [1, 2, 3] 256s with no initial value and a block 256s returns -4 256s with no block and a symbol argument 256s uses the symbol as the name of a method to reduce with 256s with no block and a string argument 256s uses the string as the name of a method to reduce with 256s 256s Immutable::List 256s #reject 256s is lazy 256s on [] 256s with a block 256s returns [] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A"] 256s with a block 256s returns ["A"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A", "B", "C"] 256s with a block 256s returns ["A", "B", "C"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A", "b", "C"] 256s with a block 256s returns ["A", "C"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["a", "b", "c"] 256s with a block 256s returns [] 256s is lazy 256s without a block 256s returns an Enumerator 256s #delete_if 256s is lazy 256s on [] 256s with a block 256s returns [] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A"] 256s with a block 256s returns ["A"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A", "B", "C"] 256s with a block 256s returns ["A", "B", "C"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A", "b", "C"] 256s with a block 256s returns ["A", "C"] 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["a", "b", "c"] 256s with a block 256s returns [] 256s is lazy 256s without a block 256s returns an Enumerator 256s 256s Immutable::List 256s #reverse 256s is lazy 256s on a really big list 256s doesn't run out of stack 256s on [] 256s preserves the original 256s returns [] 256s on ["A"] 256s preserves the original 256s returns ["A"] 256s on ["A", "B", "C"] 256s preserves the original 256s returns ["C", "B", "A"] 256s 256s Immutable::List 256s #rotate 256s when passed no argument 256s returns a new list with the first element moved to the end 256s with an integral argument n 256s returns a new list with the first (n % size) elements moved to the end 256s with a non-numeric argument 256s raises a TypeError 256s with an argument of zero (or one evenly divisible by list length) 256s it returns self 256s 256s Immutable::List 256s #sample 256s returns a randomly chosen item 256s 256s Immutable::List 256s #select 256s is lazy 256s with an empty array 256s with a block 256s preserves the original 256s returns the selected list 256s without a block 256s returns an Enumerator 256s with a single item array 256s with a block 256s preserves the original 256s returns the selected list 256s without a block 256s returns an Enumerator 256s with a multi-item array 256s with a block 256s preserves the original 256s returns the selected list 256s without a block 256s returns an Enumerator 256s with a multi-item single selectable array 256s with a block 256s preserves the original 256s returns the selected list 256s without a block 256s returns an Enumerator 256s with a multi-item multi-selectable array 256s with a block 256s preserves the original 256s returns the selected list 256s without a block 256s returns an Enumerator 256s 256s Immutable::List 256s #size 256s on a really big list 256s doesn't run out of stack 256s on [] 256s returns 0 256s on ["A"] 256s returns 1 256s on ["A", "B", "C"] 256s returns 3 256s #length 256s on a really big list 256s doesn't run out of stack 256s on [] 256s returns 0 256s on ["A"] 256s returns 1 256s on ["A", "B", "C"] 256s returns 3 256s 256s Immutable::List 256s #slice 256s when passed a positive integral index 256s returns the element at that index 256s leaves the original unchanged 256s when passed a negative integral index 256s returns the element which is number (index.abs) counting from the end of the list 256s when passed a positive integral index and count 256s returns 'count' elements starting from 'index' 256s leaves the original unchanged 256s when passed a negative integral index and count 256s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 256s when passed a Range 256s returns the elements whose indexes are within the given Range 256s leaves the original unchanged 256s when passed a subclass of Range 256s works the same as with a Range 256s #[] 256s when passed a positive integral index 256s returns the element at that index 256s leaves the original unchanged 256s when passed a negative integral index 256s returns the element which is number (index.abs) counting from the end of the list 256s when passed a positive integral index and count 256s returns 'count' elements starting from 'index' 256s leaves the original unchanged 256s when passed a negative integral index and count 256s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 256s when passed a Range 256s returns the elements whose indexes are within the given Range 256s leaves the original unchanged 256s when passed a subclass of Range 256s works the same as with a Range 256s 256s Immutable::List 256s #sort 256s is lazy 256s on [] 256s with a block 256s preserves the original 256s returns [] 256s without a block 256s preserves the original 256s returns [] 256s on ["A"] 256s with a block 256s preserves the original 256s returns ["A"] 256s without a block 256s preserves the original 256s returns ["A"] 256s on ["Ichi", "Ni", "San"] 256s with a block 256s preserves the original 256s returns ["Ni", "San", "Ichi"] 256s without a block 256s preserves the original 256s returns ["Ichi", "Ni", "San"] 256s #sort_by 256s is lazy 256s on [] 256s with a block 256s preserves the original 256s returns [] 256s without a block 256s preserves the original 256s returns [] 256s on ["A"] 256s with a block 256s preserves the original 256s returns ["A"] 256s without a block 256s preserves the original 256s returns ["A"] 256s on ["Ichi", "Ni", "San"] 256s with a block 256s preserves the original 256s returns ["Ni", "San", "Ichi"] 256s without a block 256s preserves the original 256s returns ["Ichi", "Ni", "San"] 256s 256s List#span 256s is lazy 256s given a predicate (in the form of a block), splits the list into two lists 256s (returned as an array) such that elements in the first list (the prefix) are 256s taken from the head of the list while the predicate is satisfied, and elements 256s in the second list (the remainder) are the remaining elements from the list 256s once the predicate is not satisfied. For example: 256s given the list [] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [] 256s returns the remainder as [] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [1] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [1] 256s returns the remainder as [] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [1, 2] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [1, 2] 256s returns the remainder as [] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [1, 2, 3] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [1, 2] 256s returns the remainder as [3] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [1, 2, 3, 4] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [1, 2] 256s returns the remainder as [3, 4] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [2, 3, 4] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [2] 256s returns the remainder as [3, 4] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [3, 4] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [] 256s returns the remainder as [3, 4] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s given the list [4] 256s and a predicate that returns true for values <= 2 256s preserves the original 256s returns the prefix as [] 256s returns the remainder as [4] 256s calls the block only once for each element 256s without a predicate 256s returns a frozen array 256s returns self as the prefix 256s returns an empty list as the remainder 256s 256s Immutable::List 256s #split_at 256s is lazy 256s on [] 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s on [1] 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s on [1, 2] 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s on [1, 2, 3] 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s on [1, 2, 3, 4] 256s preserves the original 256s returns a frozen array with two items 256s correctly identifies the matches 256s correctly identifies the remainder 256s 256s Immutable::List 256s #subsequences 256s yields all sublists with 1 or more consecutive items 256s with no block 256s returns an Enumerator 256s 256s Immutable::List 256s #sum 256s on a really big list 256s doesn't run out of stack 256s on [] 256s returns 0 256s on [2] 256s returns 2 256s on [1, 3, 5, 7, 11] 256s returns 27 256s 256s Immutable::List 256s #tail 256s on a really big list 256s doesn't run out of stack 256s on [] 256s preserves the original 256s returns [] 256s on ["A"] 256s preserves the original 256s returns [] 256s on ["A", "B", "C"] 256s preserves the original 256s returns ["B", "C"] 256s 256s Immutable::List 256s #tails 256s is lazy 256s on [] 256s preserves the original 256s returns [] 256s on ["A"] 256s preserves the original 256s returns [Immutable::List["A"]] 256s on ["A", "B", "C"] 256s preserves the original 256s returns [Immutable::List["A", "B", "C"], Immutable::List["B", "C"], Immutable::List["C"]] 256s 256s Immutable::List 256s #take 256s is lazy 256s 10 from [] 256s preserves the original 256s returns [] 256s 10 from ["A"] 256s preserves the original 256s returns ["A"] 256s -1 from ["A"] 256s preserves the original 256s returns [] 256s 0 from ["A", "B", "C"] 256s preserves the original 256s returns [] 256s 2 from ["A", "B", "C"] 256s preserves the original 256s returns ["A", "B"] 256s 256s Immutable::List 256s #take_while 256s is lazy 256s on [] 256s with a block 256s returns [] 256s preserves the original 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A"] 256s with a block 256s returns ["A"] 256s preserves the original 256s is lazy 256s without a block 256s returns an Enumerator 256s on ["A", "B", "C"] 256s with a block 256s returns ["A", "B"] 256s preserves the original 256s is lazy 256s without a block 256s returns an Enumerator 256s 256s Immutable::List 256s #to_a 256s on a really big list 257s doesn't run out of stack 257s on [] 257s returns [] 257s leaves the original unchanged 257s returns a mutable array 257s on ["A"] 257s returns ["A"] 257s leaves the original unchanged 257s returns a mutable array 257s on ["A", "B", "C"] 257s returns ["A", "B", "C"] 257s leaves the original unchanged 257s returns a mutable array 257s #entries 257s on a really big list 257s doesn't run out of stack 257s on [] 257s returns [] 257s leaves the original unchanged 257s returns a mutable array 257s on ["A"] 257s returns ["A"] 257s leaves the original unchanged 257s returns a mutable array 257s on ["A", "B", "C"] 257s returns ["A", "B", "C"] 257s leaves the original unchanged 257s returns a mutable array 257s 257s Immutable::List 257s #to_ary 257s on a really big list 257s doesn't run out of stack 257s enables implicit conversion to 257s block parameters 257s method arguments 257s works with splat 257s 257s Immutable::List 257s #to_list 257s on [] 257s returns self 257s on ["A"] 257s returns self 257s on ["A", "B", "C"] 257s returns self 257s 257s Immutable::List 257s #to_set 257s on [] 257s returns a set with the same values 257s on ["A"] 257s returns a set with the same values 257s on ["A", "B", "C"] 257s returns a set with the same values 257s 257s Immutable::List 257s #transpose 257s takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on 257s only goes as far as the shortest list 257s 257s Immutable::List 257s #union 257s is lazy 257s returns [] 257s for [] and [] 257s for [] and [] 257s returns ["A"] 257s for ["A"] and [] 257s for [] and ["A"] 257s returns ["A", "B", "C"] 257s for ["A", "B", "C"] and [] 257s for [] and ["A", "B", "C"] 257s returns ["A"] 257s for ["A", "A"] and ["A"] 257s for ["A"] and ["A", "A"] 257s #| 257s is lazy 257s returns [] 257s for [] and [] 257s for [] and [] 257s returns ["A"] 257s for ["A"] and [] 257s for [] and ["A"] 257s returns ["A", "B", "C"] 257s for ["A", "B", "C"] and [] 257s for [] and ["A", "B", "C"] 257s returns ["A"] 257s for ["A", "A"] and ["A"] 257s for ["A"] and ["A", "A"] 257s 257s Immutable::List 257s #uniq 257s is lazy 257s when passed a block 257s uses the block to identify duplicates 257s on [] 257s preserves the original 257s returns [] 257s on ["A"] 257s preserves the original 257s returns ["A"] 257s on ["A", "B", "C"] 257s preserves the original 257s returns ["A", "B", "C"] 257s on ["A", "B", "A", "C", "C"] 257s preserves the original 257s returns ["A", "B", "C"] 257s 257s Immutable::List 257s #zip 257s is lazy 257s on [] and [] 257s returns [] 257s on ["A"] and ["aye"] 257s returns [Immutable::List["A", "aye"]] 257s on ["A"] and [] 257s returns [Immutable::List["A", nil]] 257s on [] and ["A"] 257s returns [Immutable::List[nil, "A"]] 257s on ["A", "B", "C"] and ["aye", "bee", "see"] 257s returns [Immutable::List["A", "aye"], Immutable::List["B", "bee"], Immutable::List["C", "see"]] 257s 257s Immutable 257s .from 257s with {"a"=>1, "b"=>[2, {"c"=>3}, 4], "d"=>#, "e"=>{"f"=>8, "g"=>9}, "h"=>/ijk/} as input 257s should return Immutable::Hash["d" => Immutable::Set[7, 5, 6], "e" => Immutable::Hash["f" => 8, "g" => 9], "b" => Immutable::Vector[2, Immutable::Hash["c" => 3], 4], "a" => 1, "h" => /ijk/] 257s with {} as input 257s should return Immutable::Hash[] 257s with {"a"=>1, "b"=>2, "c"=>3} as input 257s should return Immutable::Hash["b" => 2, "a" => 1, "c" => 3] 257s with [] as input 257s should return Immutable::Vector[] 257s with [1, 2, 3] as input 257s should return Immutable::Vector[1, 2, 3] 257s with # as input 257s should return Immutable::Set[] 257s with # as input 257s should return Immutable::Set[1, 2, 3] 257s with 42 as input 257s should return 42 257s with #> as input 257s should return #> 257s with # as input 257s should return Immutable::Hash[:name => nil, :address => nil] 257s with # as input 257s should return Immutable::Hash[:name => "Dave", :address => "123 Main"] 257s with mixed object 257s should return Immutable data 257s .to_ruby 257s with Immutable::Hash["d" => Immutable::Set[7, 5, 6], "e" => Immutable::Hash["f" => 8, "g" => 9], "b" => Immutable::Vector[2, Immutable::Hash["c" => 3], 4], "a" => 1, "h" => /ijk/] as input 257s should return {"a"=>1, "b"=>[2, {"c"=>3}, 4], "d"=>#, "e"=>{"f"=>8, "g"=>9}, "h"=>/ijk/} 257s with Immutable::Hash[] as input 257s should return {} 257s with Immutable::Hash["b" => 2, "a" => 1, "c" => 3] as input 257s should return {"a"=>1, "b"=>2, "c"=>3} 257s with Immutable::Vector[] as input 257s should return [] 257s with Immutable::Vector[1, 2, 3] as input 257s should return [1, 2, 3] 257s with Immutable::Set[] as input 257s should return # 257s with Immutable::Set[1, 2, 3] as input 257s should return # 257s with 42 as input 257s should return 42 257s with #> as input 257s should return #> 257s with Immutable::Deque[] as input 257s should return [] 257s with Immutable::Deque[Immutable::Hash["a" => 1]] as input 257s should return [{"a" => 1}] 257s with Immutable::SortedSet[] as input 257s should return ::SortedSet.new 257s with Immutable::SortedSet[1, 2, 3] as input 257s should return ::SortedSet.new 257s with mixed object 257s should return Ruby data structures 257s 257s Immutable::Set 257s #add 257s can add nil to a set 257s works on large sets, with many combinations of input 257s with a unique value 257s preserves the original 257s returns a copy with the superset of values 257s with a duplicate value 257s preserves the original values 257s returns self 257s #<< 257s can add nil to a set 257s works on large sets, with many combinations of input 257s with a unique value 257s preserves the original 257s returns a copy with the superset of values 257s with a duplicate value 257s preserves the original values 257s returns self 257s #add? 257s with a unique value 257s preserves the original 257s returns a copy with the superset of values 257s with a duplicate value 257s preserves the original values 257s returns false 257s 257s Immutable::Set 257s #all? 257s when empty 257s with a block returns true 257s with no block returns true 257s when not empty 257s with a block 257s returns true if the block always returns true 257s returns false if the block ever returns false 257s propagates an exception from the block 257s stops iterating as soon as the block returns false 257s with no block 257s returns true if all values are truthy 257s returns false if any value is nil 257s returns false if any value is false 257s 257s Immutable::Set 257s #any? 257s when empty 257s with a block returns false 257s with no block returns false 257s when not empty 257s with a block 257s returns true if the block ever returns true ("A") 257s returns true if the block ever returns true ("B") 257s returns true if the block ever returns true ("C") 257s returns true if the block ever returns true (nil) 257s returns false if the block always returns false 257s propagates exceptions raised in the block 257s stops iterating as soon as the block returns true 257s with no block 257s returns true if any value is truthy 257s returns false if all values are falsey 257s 257s Immutable::Set 257s #clear 257s on [] 257s preserves the original 257s returns an empty set 257s on ["A"] 257s preserves the original 257s returns an empty set 257s on ["A", "B", "C"] 257s preserves the original 257s returns an empty set 257s from a subclass 257s returns an empty instance of the subclass 257s 257s Immutable::Set 257s #compact 257s on [] 257s preserves the original 257s returns [] 257s on ["A"] 257s preserves the original 257s returns ["A"] 257s on ["A", "B", "C"] 257s preserves the original 257s returns ["A", "B", "C"] 257s on [nil] 257s preserves the original 257s returns [] 257s on [nil, "B"] 257s preserves the original 257s returns ["B"] 257s on ["A", nil] 257s preserves the original 257s returns ["A"] 257s on [nil, nil] 257s preserves the original 257s returns [] 257s on ["A", nil, "C"] 257s preserves the original 257s returns ["A", "C"] 257s on [nil, "B", nil] 257s preserves the original 257s returns ["B"] 257s 257s Immutable::Set 257s .set 257s with no values 257s returns the empty set 257s with a list of values 257s is equivalent to repeatedly using #add 257s 257s Immutable::Set 257s #dup 257s returns self 257s #clone 257s returns self 257s 257s Immutable::Set 257s #count 257s works on large sets 257s on [] 257s with a block 257s returns 0 257s without a block 257s returns length 257s on [1] 257s with a block 257s returns 1 257s without a block 257s returns length 257s on [1, 2] 257s with a block 257s returns 1 257s without a block 257s returns length 257s on [1, 2, 3] 257s with a block 257s returns 2 257s without a block 257s returns length 257s on [1, 2, 3, 4] 257s with a block 257s returns 2 257s without a block 257s returns length 257s on [1, 2, 3, 4, 5] 257s with a block 257s returns 3 257s without a block 257s returns length 257s 257s Immutable::Set 257s #delete 257s works on large sets, with many combinations of input 257s with an existing value 257s preserves the original 257s returns a copy with the remaining values 257s with a non-existing value 257s preserves the original values 257s returns self 257s when removing the last value in a set 257s returns the canonical empty set 257s #delete? 257s with an existing value 257s preserves the original 257s returns a copy with the remaining values 257s with a non-existing value 257s preserves the original values 257s returns false 257s 257s Immutable::Set 257s #difference 257s works on a wide variety of inputs 257s for [] and [] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s doesn't modify the original Sets 257s returns ["A"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s doesn't modify the original Sets 257s returns ["A", "C"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["A", "C"] 257s doesn't modify the original Sets 257s returns ["B"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 257s doesn't modify the original Sets 257s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 257s doesn't modify the original Sets 257s returns ["A", "M", "Y", "Z"] 257s when passed a Ruby Array 257s returns the expected Set 257s #subtract 257s works on a wide variety of inputs 257s for [] and [] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s doesn't modify the original Sets 257s returns ["A"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s doesn't modify the original Sets 257s returns ["A", "C"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["A", "C"] 257s doesn't modify the original Sets 257s returns ["B"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 257s doesn't modify the original Sets 257s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 257s doesn't modify the original Sets 257s returns ["A", "M", "Y", "Z"] 257s when passed a Ruby Array 257s returns the expected Set 257s #- 257s works on a wide variety of inputs 257s for [] and [] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s doesn't modify the original Sets 257s returns ["A"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s doesn't modify the original Sets 257s returns ["A", "C"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["A", "C"] 257s doesn't modify the original Sets 257s returns ["B"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 257s doesn't modify the original Sets 257s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 257s doesn't modify the original Sets 257s returns ["A", "M", "Y", "Z"] 257s when passed a Ruby Array 257s returns the expected Set 257s 257s Immutable::Set 257s #disjoint? 257s for [] and [] 257s returns true 257s for ["A"] and [] 257s returns true 257s for [] and ["A"] 257s returns true 257s for ["A"] and ["A"] 257s returns false 257s for ["A", "B", "C"] and ["B"] 257s returns false 257s for ["B"] and ["A", "B", "C"] 257s returns false 257s for ["A", "B", "C"] and ["D", "E"] 257s returns true 257s for ["F", "G", "H", "I"] and ["A", "B", "C"] 257s returns true 257s for ["A", "B", "C"] and ["A", "B", "C"] 257s returns false 257s for ["A", "B", "C"] and ["A", "B", "C", "D"] 257s returns false 257s for ["D", "E", "F", "G"] and ["A", "B", "C"] 257s returns true 257s 257s Immutable::Set 257s #each 257s yields both of a pair of colliding keys 257s without a block 257s returns an Enumerator 257s with an empty block 257s returns self 257s with a block 257s yields all values 257s 257s Immutable::Set 257s #empty? 257s on [] 257s returns true 257s on ["A"] 257s returns false 257s on ["A", "B", "C"] 257s returns false 257s on [nil] 257s returns false 257s on [false] 257s returns false 257s .empty 257s returns the canonical empty set 257s from a subclass 257s returns an empty instance of the subclass 257s calls overridden #initialize when creating empty Set 257s 257s Immutable::Set 257s #== 257s when comparing to a standard set 257s returns false 257s when comparing to a arbitrary object 257s returns false 257s with an empty set for each comparison 257s returns true 257s with an empty set and a set with nil 257s returns false 257s with a single item array and empty array 257s returns false 257s with matching single item array 257s returns true 257s with mismatching single item array 257s returns false 257s with a multi-item array and single item array 257s returns false 257s with matching multi-item array 257s returns true 257s with a mismatching multi-item array 257s returns true 257s 257s Immutable::Set 257s #eql? 257s when comparing to a standard set 257s returns false 257s when comparing to a arbitrary object 257s returns false 257s when comparing with a subclass of Immutable::Set 257s returns false 257s with an empty set for each comparison 257s returns true 257s with an empty set and a set with nil 257s returns false 257s with a single item array and empty array 257s returns false 257s with matching single item array 257s returns true 257s with mismatching single item array 257s returns false 257s with a multi-item array and single item array 257s returns false 257s with matching multi-item array 257s returns true 257s with a mismatching multi-item array 257s returns true 257s 257s Immutable::Set 257s #exclusion 257s works for a wide variety of inputs 257s for [] and [] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s doesn't modify the original Sets 257s returns ["A"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s doesn't modify the original Sets 257s returns ["A", "C"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B", "C", "D"] 257s doesn't modify the original Sets 257s returns ["A", "D"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["D", "E", "F"] 257s doesn't modify the original Sets 257s returns ["A", "B", "C", "D", "E", "F"] 257s when passed a Ruby Array 257s returns the expected Set 257s #^ 257s works for a wide variety of inputs 257s for [] and [] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s doesn't modify the original Sets 257s returns ["A"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s doesn't modify the original Sets 257s returns [] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s doesn't modify the original Sets 257s returns ["A", "C"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B", "C", "D"] 257s doesn't modify the original Sets 257s returns ["A", "D"] 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["D", "E", "F"] 257s doesn't modify the original Sets 257s returns ["A", "B", "C", "D", "E", "F"] 257s when passed a Ruby Array 257s returns the expected Set 257s 257s Immutable::Set 257s #find 257s on [] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on [] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns "A" 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns "A" 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns "B" 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s #detect 257s on [] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on [] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns "A" 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns "A" 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns "B" 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s on ["A", "B", nil] 257s with a block 257s returns nil 257s without a block 257s returns an Enumerator 257s 257s Immutable::Set 257s #first 257s returns nil if only member of set is nil 257s returns the first item yielded by #each 257s on an empty set 257s returns nil 257s on a non-empty set 257s returns an arbitrary value from the set 257s 257s Immutable 257s #flatten 257s on ["A"] 257s preserves the original 257s returns the inlined values 257s on ["A", "B", "C"] 257s preserves the original 257s returns the inlined values 257s on ["A", Immutable::Set["B"], "C"] 257s preserves the original 257s returns the inlined values 257s on [Immutable::Set["A"], Immutable::Set["B"], Immutable::Set["C"]] 257s preserves the original 257s returns the inlined values 257s on an empty set 257s returns an empty set 257s on a set with multiple levels of nesting 257s inlines lower levels of nesting 257s from a subclass 257s returns an instance of the subclass 257s 257s Immutable::Set 257s #grep 257s without a block 257s with an empty set 257s returns the filtered values 257s with a single item set 257s returns the filtered values 257s with a single item set that doesn't contain match 257s returns the filtered values 257s with a multi-item set where one isn't a match 257s returns the filtered values 257s with a block 257s with an empty set 257s returns the filtered values 257s with a single item set 257s returns the filtered values 257s with a single item set that doesn't contain match 257s returns the filtered values 257s with a multi-item set where one isn't a match 257s returns the filtered values 257s 257s Immutable::Set 257s #grep_v 257s without a block 257s with an empty set 257s returns the filtered values 257s with a single item set 257s returns the filtered values 257s with a single item set that doesn't contain match 257s returns the filtered values 257s with a multi-item set where one isn't a match 257s returns the filtered values 257s with a block 257s resulting items are processed with the block 257s returns the filtered values 257s 257s Immutable::Set 257s #group_by 257s returns a hash without default proc 257s with a block 257s on [] 257s returns [] 257s on [1] 257s returns [{true=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{true=>Immutable::Set[1, 3], false=>Immutable::Set[2, 4]}] 257s without a block 257s on [] 257s returns [] 257s on [1] 257s returns [{1=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{1=>Immutable::Set[1], 2=>Immutable::Set[2], 3=>Immutable::Set[3], 4=>Immutable::Set[4]}] 257s on an empty set 257s returns an empty hash 257s from a subclass 257s returns an Hash whose values are instances of the subclass 257s #group 257s returns a hash without default proc 257s with a block 257s on [] 257s returns [] 257s on [1] 257s returns [{true=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{true=>Immutable::Set[1, 3], false=>Immutable::Set[2, 4]}] 257s without a block 257s on [] 257s returns [] 257s on [1] 257s returns [{1=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{1=>Immutable::Set[1], 2=>Immutable::Set[2], 3=>Immutable::Set[3], 4=>Immutable::Set[4]}] 257s on an empty set 257s returns an empty hash 257s from a subclass 257s returns an Hash whose values are instances of the subclass 257s #classify 257s returns a hash without default proc 257s with a block 257s on [] 257s returns [] 257s on [1] 257s returns [{true=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{true=>Immutable::Set[1, 3], false=>Immutable::Set[2, 4]}] 257s without a block 257s on [] 257s returns [] 257s on [1] 257s returns [{1=>Immutable::Set[1]}] 257s on [1, 2, 3, 4] 257s returns [{1=>Immutable::Set[1], 2=>Immutable::Set[2], 3=>Immutable::Set[3], 4=>Immutable::Set[4]}] 257s on an empty set 257s returns an empty hash 257s from a subclass 257s returns an Hash whose values are instances of the subclass 257s 257s Immutable::Set 257s #hash 257s generates the same hash value for a set regardless of the order things were added to it 257s values are sufficiently distributed 257s on an empty set 257s returns 0 257s 257s Immutable::Set 257s #include? 257s returns true for an existing value ("A") 257s returns true for an existing value ("B") 257s returns true for an existing value ("C") 257s returns true for an existing value (2.0) 257s returns true for an existing value (nil) 257s returns false for a non-existing value 257s returns true even if existing value is nil 257s returns true even if existing value is false 257s returns false for a mutable item which is mutated after adding 257s uses #eql? for equality 257s returns the right answers after a lot of addings and removings 257s #member? 257s returns true for an existing value ("A") 257s returns true for an existing value ("B") 257s returns true for an existing value ("C") 257s returns true for an existing value (2.0) 257s returns true for an existing value (nil) 257s returns false for a non-existing value 257s returns true even if existing value is nil 257s returns true even if existing value is false 257s returns false for a mutable item which is mutated after adding 257s uses #eql? for equality 257s returns the right answers after a lot of addings and removings 257s 257s Immutable::Set 257s #inspect 257s on [] 257s returns "Immutable::Set[]" 257s returns a string which can be eval'd to get an equivalent set 257s on ["A"] 257s returns "Immutable::Set[\"A\"]" 257s returns a string which can be eval'd to get an equivalent set 257s on ["A", "B", "C"] 257s returns a programmer-readable representation of the set contents 257s returns a string which can be eval'd to get an equivalent set 257s from a subclass 257s returns a programmer-readable representation of the set contents 257s returns a string which can be eval'd to get an equivalent set 257s 257s Immutable::Set 257s #intersect? 257s for [] and [] 257s returns false 257s for ["A"] and [] 257s returns false 257s for [] and ["A"] 257s returns false 257s for ["A"] and ["A"] 257s returns true 257s for ["A", "B", "C"] and ["B"] 257s returns true 257s for ["B"] and ["A", "B", "C"] 257s returns true 257s for ["A", "B", "C"] and ["D", "E"] 257s returns false 257s for ["F", "G", "H", "I"] and ["A", "B", "C"] 257s returns false 257s for ["A", "B", "C"] and ["A", "B", "C"] 257s returns true 257s for ["A", "B", "C"] and ["A", "B", "C", "D"] 257s returns true 257s for ["D", "E", "F", "G"] and ["A", "B", "C"] 257s returns false 257s 257s Immutable::Set 257s #intersection 257s returns results consistent with Array#& 257s for [] and [] 257s returns [], without changing the original Sets 257s for [] and [] 257s returns [], without changing the original Sets 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and [] 257s returns [], without changing the original Sets 257s for [] and ["A"] 257s returns [], without changing the original Sets 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A"] and ["A"] 257s returns ["A"], without changing the original Sets 257s for ["A"] and ["A"] 257s returns ["A"], without changing the original Sets 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["B"] 257s returns ["B"], without changing the original Sets 257s for ["B"] and ["A", "B", "C"] 257s returns ["B"], without changing the original Sets 257s when passed a Ruby Array 257s returns the expected Set 257s for ["A", "B", "C"] and ["A", "C"] 258s returns ["A", "C"], without changing the original Sets 258s for ["A", "C"] and ["A", "B", "C"] 258s returns ["A", "C"], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s #& 258s returns results consistent with Array#& 258s for [] and [] 258s returns [], without changing the original Sets 258s for [] and [] 258s returns [], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s for ["A"] and [] 258s returns [], without changing the original Sets 258s for [] and ["A"] 258s returns [], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s for ["A"] and ["A"] 258s returns ["A"], without changing the original Sets 258s for ["A"] and ["A"] 258s returns ["A"], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s for ["A", "B", "C"] and ["B"] 258s returns ["B"], without changing the original Sets 258s for ["B"] and ["A", "B", "C"] 258s returns ["B"], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s for ["A", "B", "C"] and ["A", "C"] 258s returns ["A", "C"], without changing the original Sets 258s for ["A", "C"] and ["A", "B", "C"] 258s returns ["A", "C"], without changing the original Sets 258s when passed a Ruby Array 258s returns the expected Set 258s 258s Immutable::Set 258s #join 258s with a separator 258s on [] 258s preserves the original 258s returns "" 258s on ["A"] 258s preserves the original 258s returns "A" 258s on ["A", "B", "C"] 258s preserves the original 258s returns "A|B|C" 258s without a separator 258s on [] 258s preserves the original 258s returns "" 258s on ["A"] 258s preserves the original 258s returns "A" 258s on ["A", "B", "C"] 258s preserves the original 258s returns "ABC" 258s without a separator (with global default separator set) 258s on ['A', 'B', 'C'] 258s preserves the original 258s returns nil 258s 258s Immutable::Set 258s #map 258s works on large sets 258s when empty 258s returns self 258s when not empty 258s with a block 258s preserves the original values 258s returns a new set with the mapped values 258s with no block 258s returns an Enumerator 258s from a subclass 258s returns an instance of the subclass 258s when multiple items map to the same value 258s filters out the duplicates 258s #collect 258s works on large sets 258s when empty 258s returns self 258s when not empty 258s with a block 258s preserves the original values 258s returns a new set with the mapped values 258s with no block 258s returns an Enumerator 258s from a subclass 258s returns an instance of the subclass 258s when multiple items map to the same value 258s filters out the duplicates 258s 258s Immutable::Set 258s #marshal_dump/#marshal_load 258s can survive dumping and loading into a new process 258s is still possible to test items by key after loading 258s 258s Immutable::Set 258s #max 258s with a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "Ichi" 258s without a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "San" 258s 258s Immutable::Set 258s #min 258s with a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "Ni" 258s without a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "Ichi" 258s 258s Immutable::Set 258s .new 258s initializes a new set 258s accepts a Range 258s returns a Set which doesn't change even if the initializer is mutated 258s is amenable to overriding of #initialize 258s from a subclass 258s returns a frozen instance of the subclass 258s [] 258s accepts any number of arguments and initializes a new set 258s 258s Immutable::Set 258s #none? 258s when empty 258s with a block returns true 258s with no block returns true 258s when not empty 258s with a block 258s returns false if the block ever returns true ("A") 258s returns false if the block ever returns true ("B") 258s returns false if the block ever returns true ("C") 258s returns false if the block ever returns true (nil) 258s returns true if the block always returns false 258s stops iterating as soon as the block returns true 258s with no block 258s returns false if any value is truthy 258s returns true if all values are falsey 258s 258s Immutable::Set 258s #one? 258s when empty 258s with a block returns false 258s with no block returns false 258s when not empty 258s with a block 258s returns false if the block returns true more than once 258s returns false if the block never returns true 258s returns true if the block only returns true once 258s with no block 258s returns false if more than one value is truthy 258s returns true if only one value is truthy 258s returns false if no values are truthy 258s 258s Immutable::Set 258s #partition 258s on [] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2, 3] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2, 3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [2, 3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s 258s Immutable::Set 258s #product 258s on [] 258s returns 1 258s doesn't change the original Set 258s on [2] 258s returns 2 258s doesn't change the original Set 258s on [1, 3, 5, 7, 11] 258s returns 1155 258s doesn't change the original Set 258s 258s Immutable::Set 258s #reduce 258s on [] 258s with an initial value of 10 258s and a block 258s returns 10 258s on [1] 258s with an initial value of 10 258s and a block 258s returns 9 258s on [1, 2, 3] 258s with an initial value of 10 258s and a block 258s returns 4 258s on [] 258s with no initial value 258s and a block 258s returns nil 258s on [1] 258s with no initial value 258s and a block 258s returns 1 258s on [1, 2, 3] 258s with no initial value 258s and a block 258s returns 6 258s with no block and a symbol argument 258s uses the symbol as the name of a method to reduce with 258s with no block and a string argument 258s uses the string as the name of a method to reduce with 258s #inject 258s on [] 258s with an initial value of 10 258s and a block 258s returns 10 258s on [1] 258s with an initial value of 10 258s and a block 258s returns 9 258s on [1, 2, 3] 258s with an initial value of 10 258s and a block 258s returns 4 258s on [] 258s with no initial value 258s and a block 258s returns nil 258s on [1] 258s with no initial value 258s and a block 258s returns 1 258s on [1, 2, 3] 258s with no initial value 258s and a block 258s returns 6 258s with no block and a symbol argument 258s uses the symbol as the name of a method to reduce with 258s with no block and a string argument 258s uses the string as the name of a method to reduce with 258s 258s Immutable::Set 258s #reject 258s when nothing matches 258s returns self 258s when only some things match 258s with a block 258s preserves the original 258s returns a set with the matching values 258s with no block 258s returns self 258s on a large set, with many combinations of input 258s still works 258s #delete_if 258s when nothing matches 258s returns self 258s when only some things match 258s with a block 258s preserves the original 258s returns a set with the matching values 258s with no block 258s returns self 258s on a large set, with many combinations of input 258s still works 258s 258s Immutable::Set 258s #reverse_each 258s without a block 258s returns an Enumerator 258s with an empty block 258s returns self 258s with a block 258s yields all values 258s 258s Immutable::Set 258s #sample 258s returns a randomly chosen item 258s 258s Immutable::Set 258s #select 259s works on a large set, with many combinations of input 259s when everything matches 259s returns self 259s when only some things match 259s with a block 259s preserves the original 259s returns a set with the matching values 259s with no block 259s returns an Enumerator 259s when nothing matches 259s preserves the original 259s returns the canonical empty set 259s from a subclass 259s returns an instance of the same class 259s #find_all 259s works on a large set, with many combinations of input 259s when everything matches 259s returns self 259s when only some things match 259s with a block 259s preserves the original 259s returns a set with the matching values 259s with no block 259s returns an Enumerator 259s when nothing matches 259s preserves the original 259s returns the canonical empty set 259s from a subclass 259s returns an instance of the same class 259s 259s Immutable::Set 259s #size 259s returns 0 for [] 259s returns 1 for ["A"] 259s returns 3 for ["A", "B", "C"] 259s #length 259s returns 0 for [] 259s returns 1 for ["A"] 259s returns 3 for ["A", "B", "C"] 259s 259s Immutable::Set 259s #sort 259s on [] 259s with a block 259s returns [] 259s doesn't change the original Set 259s without a block 259s returns [] 259s doesn't change the original Set 259s on ["A"] 259s with a block 259s returns ["A"] 259s doesn't change the original Set 259s without a block 259s returns ["A"] 259s doesn't change the original Set 259s on ["Ichi", "Ni", "San"] 259s with a block 259s returns ["Ni", "San", "Ichi"] 259s doesn't change the original Set 259s without a block 259s returns ["Ichi", "Ni", "San"] 259s doesn't change the original Set 259s #sort_by 259s on [] 259s with a block 259s returns [] 259s doesn't change the original Set 259s without a block 259s returns [] 259s doesn't change the original Set 259s on ["A"] 259s with a block 259s returns ["A"] 259s doesn't change the original Set 259s without a block 259s returns ["A"] 259s doesn't change the original Set 259s on ["Ichi", "Ni", "San"] 259s with a block 259s returns ["Ni", "San", "Ichi"] 259s doesn't change the original Set 259s without a block 259s returns ["Ichi", "Ni", "San"] 259s doesn't change the original Set 259s #sort_by 259s calls the passed block no more than twice for each item 259s 259s Immutable::Set 259s #subset? 259s for [] and [] 259s returns true 259s for ["A"] and [] 259s returns false 259s for [] and ["A"] 259s returns true 259s for ["A"] and ["A"] 259s returns true 259s for ["A", "B", "C"] and ["B"] 259s returns false 259s for ["B"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "C"] 259s returns false 259s for ["A", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns true 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns false 259s #<= 259s for [] and [] 259s returns true 259s for ["A"] and [] 259s returns false 259s for [] and ["A"] 259s returns true 259s for ["A"] and ["A"] 259s returns true 259s for ["A", "B", "C"] and ["B"] 259s returns false 259s for ["B"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "C"] 259s returns false 259s for ["A", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns true 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns false 259s #proper_subset? 259s for [] and [] 259s returns false 259s for ["A"] and [] 259s returns false 259s for [] and ["A"] 259s returns true 259s for ["A"] and ["A"] 259s returns false 259s for ["A", "B", "C"] and ["B"] 259s returns false 259s for ["B"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "C"] 259s returns false 259s for ["A", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns true 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns false 259s #< 259s for [] and [] 259s returns false 259s for ["A"] and [] 259s returns false 259s for [] and ["A"] 259s returns true 259s for ["A"] and ["A"] 259s returns false 259s for ["A", "B", "C"] and ["B"] 259s returns false 259s for ["B"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "C"] 259s returns false 259s for ["A", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns true 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns false 259s 259s Immutable::Set 259s #sum 259s on [] 259s returns 0 259s doesn't change the original Set 259s on [2] 259s returns 2 259s doesn't change the original Set 259s on [1, 3, 5, 7, 11] 259s returns 27 259s doesn't change the original Set 259s 259s Immutable::Set 259s #superset? 259s for [] and [] 259s returns true 259s for ["A"] and [] 259s returns true 259s for [] and ["A"] 259s returns false 259s for ["A"] and ["A"] 259s returns true 259s for ["A", "B", "C"] and ["B"] 259s returns true 259s for ["B"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "C"] 259s returns true 259s for ["A", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns false 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns true 259s #>= 259s for [] and [] 259s returns true 259s for ["A"] and [] 259s returns true 259s for [] and ["A"] 259s returns false 259s for ["A"] and ["A"] 259s returns true 259s for ["A", "B", "C"] and ["B"] 259s returns true 259s for ["B"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "C"] 259s returns true 259s for ["A", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns false 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns true 259s #proper_superset? 259s for [] and [] 259s returns false 259s for ["A"] and [] 259s returns true 259s for [] and ["A"] 259s returns false 259s for ["A"] and ["A"] 259s returns false 259s for ["A", "B", "C"] and ["B"] 259s returns true 259s for ["B"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "C"] 259s returns true 259s for ["A", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns false 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns true 259s #> 259s for [] and [] 259s returns false 259s for ["A"] and [] 259s returns true 259s for [] and ["A"] 259s returns false 259s for ["A"] and ["A"] 259s returns false 259s for ["A", "B", "C"] and ["B"] 259s returns true 259s for ["B"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "C"] 259s returns true 259s for ["A", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns false 259s for ["A", "B", "C", "D"] and ["A", "B", "C"] 259s returns true 259s 259s Immutable::Set 259s #to_a 259s on 'a'..'a' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'b' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'c' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'d' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'e' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'f' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'g' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'h' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'i' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'j' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'k' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'l' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'m' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'n' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'o' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'p' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'q' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'r' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'s' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'t' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'u' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'v' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'w' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'x' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'y' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'z' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s #entries 259s on 'a'..'a' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'b' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'c' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'d' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'e' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'f' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'g' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'h' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'i' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'j' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'k' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'l' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'m' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'n' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'o' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'p' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'q' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'r' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'s' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'t' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'u' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'v' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'w' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'x' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'y' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s on 'a'..'z' 259s returns an equivalent array 259s doesn't change the original Set 259s returns a mutable array 259s 259s Immutable::Set 259s #to_list 259s on [] 259s returns a list 259s doesn't change the original Set 259s the returned list 259s has the correct length 259s contains all values 259s on ["A"] 259s returns a list 259s doesn't change the original Set 259s the returned list 259s has the correct length 259s contains all values 259s on ["A", "B", "C"] 259s returns a list 259s doesn't change the original Set 259s the returned list 259s has the correct length 259s contains all values 259s 259s Immutable::Set 259s #to_set 259s on [] 259s returns self 259s on ["A"] 259s returns self 259s on ["A", "B", "C"] 259s returns self 259s 259s Immutable::Set 259s #union 259s for [] and [] 259s returns [], without changing the original Sets 259s for [] and [] 259s returns [], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and [] 259s returns ["A", "B", "C"], without changing the original Sets 259s for [] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["X", "Y", "Z"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s for ["X", "Y", "Z"] and ["A", "B", "C"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s when receiving a subset 259s returns self 259s #| 259s for [] and [] 259s returns [], without changing the original Sets 259s for [] and [] 259s returns [], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and [] 259s returns ["A", "B", "C"], without changing the original Sets 259s for [] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["X", "Y", "Z"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s for ["X", "Y", "Z"] and ["A", "B", "C"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s when receiving a subset 259s returns self 259s #+ 259s for [] and [] 259s returns [], without changing the original Sets 259s for [] and [] 259s returns [], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and [] 259s returns ["A", "B", "C"], without changing the original Sets 259s for [] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["X", "Y", "Z"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s for ["X", "Y", "Z"] and ["A", "B", "C"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s when receiving a subset 259s returns self 259s #merge 259s for [] and [] 259s returns [], without changing the original Sets 259s for [] and [] 259s returns [], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and ["A"] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for [] and ["A"] 259s returns ["A"], without changing the original Sets 259s for ["A"] and [] 259s returns ["A"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and [] 259s returns ["A", "B", "C"], without changing the original Sets 259s for [] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns ["A", "B", "C"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s for ["A", "B", "C"] and ["X", "Y", "Z"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s for ["X", "Y", "Z"] and ["A", "B", "C"] 259s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 259s when passed a Ruby Array 259s returns the expected Set 259s from a subclass 259s returns an instance of the subclass 259s when receiving a subset 259s returns self 259s 259s Immutable::SortedSet 259s #above 259s when called without a block 259s returns a sorted set of all items higher than the argument 259s when called with a block 259s yields all the items higher than the argument 259s on an empty set 259s returns an empty set 259s with an argument higher than all the values in the set 259s returns an empty set 259s 259s Immutable::SortedSet 259s #add 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values (in order) 259s with a duplicate value 259s preserves the original values 259s returns self 259s on a set ordered by a comparator 259s inserts the new item in the correct place 259s #<< 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values (in order) 259s with a duplicate value 259s preserves the original values 259s returns self 259s on a set ordered by a comparator 259s inserts the new item in the correct place 259s #add? 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values 259s with a duplicate value 259s preserves the original values 259s returns false 259s 259s Immutable::SortedSet 259s #at 259s [] with 10 259s returns nil 259s ["A"] with 10 259s returns nil 259s ["A", "B", "C"] with 0 259s returns "A" 259s ["A", "B", "C"] with 1 259s returns "B" 259s ["A", "B", "C"] with 2 259s returns "C" 259s ["A", "B", "C"] with 3 259s returns nil 259s ["A", "B", "C"] with -1 259s returns "C" 259s ["A", "B", "C"] with -2 259s returns "B" 259s ["A", "B", "C"] with -3 259s returns "A" 259s ["A", "B", "C"] with -4 259s returns nil 259s 259s Immutable::SortedSet 259s #below 259s when called without a block 259s returns a sorted set of all items lower than the argument 259s when called with a block 259s yields all the items lower than the argument 259s on an empty set 259s returns an empty set 259s with an argument lower than all the values in the set 259s returns an empty set 259s 259s Immutable::SortedSet 259s #between 259s when called without a block 259s returns a sorted set of all items from the first argument to the second 259s when called with a block 259s yields all the items lower than the argument 259s on an empty set 259s returns an empty set 259s with a 'to' argument lower than the 'from' argument 259s returns an empty set 259s 259s Immutable::SortedSet 259s #clear 259s on [] 259s preserves the original 259s returns an empty set 259s on ["A"] 259s preserves the original 259s returns an empty set 259s on ["A", "B", "C"] 259s preserves the original 259s returns an empty set 259s from a subclass 259s returns an empty instance of the subclass 259s with a comparator 259s returns an empty instance with same comparator 259s 259s Immutable::SortedSet 259s on [] 259s returns self 259s on ["A"] 259s returns self 259s on ["A", "B", "C"] 259s returns self 259s on 1..32 259s returns self 259s on [] 259s returns self 259s on ["A"] 259s returns self 259s on ["A", "B", "C"] 259s returns self 259s on 1..32 259s returns self 259s 259s Immutable::SortedSet 259s #delete_at 259s removes the element at the specified index 259s makes no modification if the index is out of range 259s 259s Immutable::SortedSet 259s #delete 259s on an empty set 259s returns an empty set 259s with an existing value 259s preserves the original 259s returns a copy with the remaining of values 259s with a non-existing value 259s preserves the original values 259s returns self 259s when removing the last value in a sorted set 259s maintains the set order 259s when the set is in natural order 259s returns the canonical empty set 259s on [1, 2, 3], when deleting [1, 2, 3] 259s returns [] 259s on [1, 2, 3, 4], when deleting [1, 2, 3] 259s returns [4] 259s on [1, 2, 3, 4], when deleting [1, 2, 4] 259s returns [3] 259s on [1, 2, 3, 4], when deleting [1, 3, 4] 259s returns [2] 259s on [1, 2, 3, 4], when deleting [2, 3, 4] 259s returns [1] 259s on [1, 2, 3, 4, 5], when deleting [1, 2, 3] 259s returns [4, 5] 259s on [1, 2, 3, 4, 5], when deleting [1, 2, 4] 259s returns [3, 5] 259s on [1, 2, 3, 4, 5], when deleting [1, 2, 5] 259s returns [3, 4] 259s on [1, 2, 3, 4, 5], when deleting [1, 3, 4] 259s returns [2, 5] 259s on [1, 2, 3, 4, 5], when deleting [1, 3, 5] 259s returns [2, 4] 259s on [1, 2, 3, 4, 5], when deleting [1, 4, 5] 259s returns [2, 3] 259s on [1, 2, 3, 4, 5], when deleting [2, 3, 4] 259s returns [1, 5] 259s on [1, 2, 3, 4, 5], when deleting [2, 3, 5] 259s returns [1, 4] 259s on [1, 2, 3, 4, 5], when deleting [2, 4, 5] 259s returns [1, 3] 259s on [1, 2, 3, 4, 5], when deleting [3, 4, 5] 259s returns [1, 2] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 3] 259s returns [4, 5, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 4] 259s returns [3, 5, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 5] 259s returns [3, 4, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 6] 259s returns [3, 4, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 4] 259s returns [2, 5, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 5] 259s returns [2, 4, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 6] 259s returns [2, 4, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 4, 5] 259s returns [2, 3, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 4, 6] 259s returns [2, 3, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [1, 5, 6] 259s returns [2, 3, 4] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 4] 259s returns [1, 5, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 5] 259s returns [1, 4, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 6] 259s returns [1, 4, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 4, 5] 259s returns [1, 3, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 4, 6] 259s returns [1, 3, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [2, 5, 6] 259s returns [1, 3, 4] 259s on [1, 2, 3, 4, 5, 6], when deleting [3, 4, 5] 259s returns [1, 2, 6] 259s on [1, 2, 3, 4, 5, 6], when deleting [3, 4, 6] 259s returns [1, 2, 5] 259s on [1, 2, 3, 4, 5, 6], when deleting [3, 5, 6] 259s returns [1, 2, 4] 259s on [1, 2, 3, 4, 5, 6], when deleting [4, 5, 6] 259s returns [1, 2, 3] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 3] 259s returns [4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 4] 259s returns [3, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 5] 259s returns [3, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 6] 259s returns [3, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 7] 259s returns [3, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 4] 259s returns [2, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 5] 259s returns [2, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 6] 259s returns [2, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 7] 259s returns [2, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 5] 259s returns [2, 3, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 6] 259s returns [2, 3, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 7] 259s returns [2, 3, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 5, 6] 259s returns [2, 3, 4, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 5, 7] 259s returns [2, 3, 4, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 6, 7] 259s returns [2, 3, 4, 5] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 4] 259s returns [1, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 5] 259s returns [1, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 6] 259s returns [1, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 7] 259s returns [1, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 5] 259s returns [1, 3, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 6] 259s returns [1, 3, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 7] 259s returns [1, 3, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 5, 6] 259s returns [1, 3, 4, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 5, 7] 259s returns [1, 3, 4, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 6, 7] 259s returns [1, 3, 4, 5] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 5] 259s returns [1, 2, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 6] 259s returns [1, 2, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 7] 259s returns [1, 2, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 5, 6] 259s returns [1, 2, 4, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 5, 7] 259s returns [1, 2, 4, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 6, 7] 259s returns [1, 2, 4, 5] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 5, 6] 259s returns [1, 2, 3, 7] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 5, 7] 259s returns [1, 2, 3, 6] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 6, 7] 259s returns [1, 2, 3, 5] 259s on [1, 2, 3, 4, 5, 6, 7], when deleting [5, 6, 7] 259s returns [1, 2, 3, 4] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 3] 259s returns [4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 4] 259s returns [3, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 5] 259s returns [3, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 6] 259s returns [3, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 7] 259s returns [3, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 8] 259s returns [3, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 4] 259s returns [2, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 5] 259s returns [2, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 6] 259s returns [2, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 7] 259s returns [2, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 8] 259s returns [2, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 5] 259s returns [2, 3, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 6] 259s returns [2, 3, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 7] 259s returns [2, 3, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 8] 259s returns [2, 3, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 6] 259s returns [2, 3, 4, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 7] 259s returns [2, 3, 4, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 8] 259s returns [2, 3, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 6, 7] 259s returns [2, 3, 4, 5, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 6, 8] 259s returns [2, 3, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 7, 8] 259s returns [2, 3, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 4] 259s returns [1, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 5] 259s returns [1, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 6] 259s returns [1, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 7] 259s returns [1, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 8] 259s returns [1, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 5] 259s returns [1, 3, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 6] 259s returns [1, 3, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 7] 259s returns [1, 3, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 8] 259s returns [1, 3, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 6] 259s returns [1, 3, 4, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 7] 259s returns [1, 3, 4, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 8] 259s returns [1, 3, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 6, 7] 259s returns [1, 3, 4, 5, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 6, 8] 259s returns [1, 3, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 7, 8] 259s returns [1, 3, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 5] 259s returns [1, 2, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 6] 259s returns [1, 2, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 7] 259s returns [1, 2, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 8] 259s returns [1, 2, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 6] 259s returns [1, 2, 4, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 7] 259s returns [1, 2, 4, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 8] 259s returns [1, 2, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 6, 7] 259s returns [1, 2, 4, 5, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 6, 8] 259s returns [1, 2, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 7, 8] 259s returns [1, 2, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 6] 259s returns [1, 2, 3, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 7] 259s returns [1, 2, 3, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 8] 259s returns [1, 2, 3, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 6, 7] 259s returns [1, 2, 3, 5, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 6, 8] 259s returns [1, 2, 3, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 7, 8] 259s returns [1, 2, 3, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 6, 7] 259s returns [1, 2, 3, 4, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 6, 8] 259s returns [1, 2, 3, 4, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 7, 8] 259s returns [1, 2, 3, 4, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [6, 7, 8] 259s returns [1, 2, 3, 4, 5] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 3] 259s returns [4, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 4] 259s returns [3, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 5] 259s returns [3, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 6] 259s returns [3, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 7] 259s returns [3, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 8] 259s returns [3, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 9] 259s returns [3, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 4] 259s returns [2, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 5] 259s returns [2, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 6] 259s returns [2, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 7] 259s returns [2, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 8] 259s returns [2, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 9] 259s returns [2, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 5] 259s returns [2, 3, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 6] 259s returns [2, 3, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 7] 259s returns [2, 3, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 8] 259s returns [2, 3, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 9] 259s returns [2, 3, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 6] 259s returns [2, 3, 4, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 7] 259s returns [2, 3, 4, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 8] 259s returns [2, 3, 4, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 9] 259s returns [2, 3, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 7] 259s returns [2, 3, 4, 5, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 8] 259s returns [2, 3, 4, 5, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 9] 259s returns [2, 3, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 7, 8] 259s returns [2, 3, 4, 5, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 7, 9] 259s returns [2, 3, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 8, 9] 259s returns [2, 3, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 4] 259s returns [1, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 5] 259s returns [1, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 6] 259s returns [1, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 7] 259s returns [1, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 8] 259s returns [1, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 9] 259s returns [1, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 5] 259s returns [1, 3, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 6] 259s returns [1, 3, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 7] 259s returns [1, 3, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 8] 259s returns [1, 3, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 9] 259s returns [1, 3, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 6] 259s returns [1, 3, 4, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 7] 259s returns [1, 3, 4, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 8] 259s returns [1, 3, 4, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 9] 259s returns [1, 3, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 7] 259s returns [1, 3, 4, 5, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 8] 259s returns [1, 3, 4, 5, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 9] 259s returns [1, 3, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 7, 8] 259s returns [1, 3, 4, 5, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 7, 9] 259s returns [1, 3, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 8, 9] 259s returns [1, 3, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 5] 259s returns [1, 2, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 6] 259s returns [1, 2, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 7] 259s returns [1, 2, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 8] 259s returns [1, 2, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 9] 259s returns [1, 2, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 6] 259s returns [1, 2, 4, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 7] 259s returns [1, 2, 4, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 8] 259s returns [1, 2, 4, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 9] 259s returns [1, 2, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 7] 259s returns [1, 2, 4, 5, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 8] 259s returns [1, 2, 4, 5, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 9] 259s returns [1, 2, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 7, 8] 259s returns [1, 2, 4, 5, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 7, 9] 259s returns [1, 2, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 8, 9] 259s returns [1, 2, 4, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 6] 259s returns [1, 2, 3, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 7] 259s returns [1, 2, 3, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 8] 259s returns [1, 2, 3, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 9] 259s returns [1, 2, 3, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 7] 259s returns [1, 2, 3, 5, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 8] 259s returns [1, 2, 3, 5, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 9] 259s returns [1, 2, 3, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 7, 8] 259s returns [1, 2, 3, 5, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 7, 9] 259s returns [1, 2, 3, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 8, 9] 259s returns [1, 2, 3, 5, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 7] 259s returns [1, 2, 3, 4, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 8] 259s returns [1, 2, 3, 4, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 9] 259s returns [1, 2, 3, 4, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 7, 8] 259s returns [1, 2, 3, 4, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 7, 9] 259s returns [1, 2, 3, 4, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 8, 9] 259s returns [1, 2, 3, 4, 6, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 7, 8] 259s returns [1, 2, 3, 4, 5, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 7, 9] 259s returns [1, 2, 3, 4, 5, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 8, 9] 259s returns [1, 2, 3, 4, 5, 7] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [7, 8, 9] 259s returns [1, 2, 3, 4, 5, 6] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 3] 259s returns [4, 5, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 4] 259s returns [3, 5, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 5] 259s returns [3, 4, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 6] 259s returns [3, 4, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 7] 259s returns [3, 4, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 8] 259s returns [3, 4, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 9] 259s returns [3, 4, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 10] 259s returns [3, 4, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 4] 259s returns [2, 5, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 5] 259s returns [2, 4, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 6] 259s returns [2, 4, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 7] 259s returns [2, 4, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 8] 259s returns [2, 4, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 9] 259s returns [2, 4, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 10] 259s returns [2, 4, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 5] 259s returns [2, 3, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 6] 259s returns [2, 3, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 7] 259s returns [2, 3, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 8] 259s returns [2, 3, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 9] 259s returns [2, 3, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 10] 259s returns [2, 3, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 6] 259s returns [2, 3, 4, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 7] 259s returns [2, 3, 4, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 8] 259s returns [2, 3, 4, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 9] 259s returns [2, 3, 4, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 10] 259s returns [2, 3, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 7] 259s returns [2, 3, 4, 5, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 8] 259s returns [2, 3, 4, 5, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 9] 259s returns [2, 3, 4, 5, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 10] 259s returns [2, 3, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 8] 259s returns [2, 3, 4, 5, 6, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 9] 259s returns [2, 3, 4, 5, 6, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 10] 259s returns [2, 3, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 8, 9] 259s returns [2, 3, 4, 5, 6, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 8, 10] 259s returns [2, 3, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 9, 10] 259s returns [2, 3, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 4] 259s returns [1, 5, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 5] 259s returns [1, 4, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 6] 259s returns [1, 4, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 7] 259s returns [1, 4, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 8] 259s returns [1, 4, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 9] 259s returns [1, 4, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 10] 259s returns [1, 4, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 5] 259s returns [1, 3, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 6] 259s returns [1, 3, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 7] 259s returns [1, 3, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 8] 259s returns [1, 3, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 9] 259s returns [1, 3, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 10] 259s returns [1, 3, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 6] 259s returns [1, 3, 4, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 7] 259s returns [1, 3, 4, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 8] 259s returns [1, 3, 4, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 9] 259s returns [1, 3, 4, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 10] 259s returns [1, 3, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 7] 259s returns [1, 3, 4, 5, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 8] 259s returns [1, 3, 4, 5, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 9] 259s returns [1, 3, 4, 5, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 10] 259s returns [1, 3, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 8] 259s returns [1, 3, 4, 5, 6, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 9] 259s returns [1, 3, 4, 5, 6, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 10] 259s returns [1, 3, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 8, 9] 259s returns [1, 3, 4, 5, 6, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 8, 10] 259s returns [1, 3, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 9, 10] 259s returns [1, 3, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 5] 259s returns [1, 2, 6, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 6] 259s returns [1, 2, 5, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 7] 259s returns [1, 2, 5, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 8] 259s returns [1, 2, 5, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 9] 259s returns [1, 2, 5, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 10] 259s returns [1, 2, 5, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 6] 259s returns [1, 2, 4, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 7] 259s returns [1, 2, 4, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 8] 259s returns [1, 2, 4, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 9] 259s returns [1, 2, 4, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 10] 259s returns [1, 2, 4, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 7] 259s returns [1, 2, 4, 5, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 8] 259s returns [1, 2, 4, 5, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 9] 259s returns [1, 2, 4, 5, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 10] 259s returns [1, 2, 4, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 8] 259s returns [1, 2, 4, 5, 6, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 9] 259s returns [1, 2, 4, 5, 6, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 10] 259s returns [1, 2, 4, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 8, 9] 259s returns [1, 2, 4, 5, 6, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 8, 10] 259s returns [1, 2, 4, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 9, 10] 259s returns [1, 2, 4, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 6] 259s returns [1, 2, 3, 7, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 7] 259s returns [1, 2, 3, 6, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 8] 259s returns [1, 2, 3, 6, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 9] 259s returns [1, 2, 3, 6, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 10] 259s returns [1, 2, 3, 6, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 7] 259s returns [1, 2, 3, 5, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 8] 259s returns [1, 2, 3, 5, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 9] 259s returns [1, 2, 3, 5, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 10] 259s returns [1, 2, 3, 5, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 8] 259s returns [1, 2, 3, 5, 6, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 9] 259s returns [1, 2, 3, 5, 6, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 10] 259s returns [1, 2, 3, 5, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 8, 9] 259s returns [1, 2, 3, 5, 6, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 8, 10] 259s returns [1, 2, 3, 5, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 9, 10] 259s returns [1, 2, 3, 5, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 7] 259s returns [1, 2, 3, 4, 8, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 8] 259s returns [1, 2, 3, 4, 7, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 9] 259s returns [1, 2, 3, 4, 7, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 10] 259s returns [1, 2, 3, 4, 7, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 8] 259s returns [1, 2, 3, 4, 6, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 9] 259s returns [1, 2, 3, 4, 6, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 10] 259s returns [1, 2, 3, 4, 6, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 8, 9] 259s returns [1, 2, 3, 4, 6, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 8, 10] 259s returns [1, 2, 3, 4, 6, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 9, 10] 259s returns [1, 2, 3, 4, 6, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 8] 259s returns [1, 2, 3, 4, 5, 9, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 9] 259s returns [1, 2, 3, 4, 5, 8, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 10] 259s returns [1, 2, 3, 4, 5, 8, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 8, 9] 259s returns [1, 2, 3, 4, 5, 7, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 8, 10] 259s returns [1, 2, 3, 4, 5, 7, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 9, 10] 259s returns [1, 2, 3, 4, 5, 7, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 8, 9] 259s returns [1, 2, 3, 4, 5, 6, 10] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 8, 10] 259s returns [1, 2, 3, 4, 5, 6, 9] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 9, 10] 259s returns [1, 2, 3, 4, 5, 6, 8] 259s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [8, 9, 10] 259s returns [1, 2, 3, 4, 5, 6, 7] 259s #delete? 259s with an existing value 259s preserves the original 259s returns a copy with the remaining values 259s with a non-existing value 259s preserves the original values 259s returns false 259s 259s Immutable::SortedSet 259s #difference 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns [] 259s for ["A", "B", "C"] and ["B"] 259s returns ["A", "C"] 259s for ["A", "B", "C"] and ["A", "C"] 259s returns ["B"] 259s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 259s returns ["A", "C", "D"] 259s #subtract 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns [] 259s for ["A", "B", "C"] and ["B"] 259s returns ["A", "C"] 259s for ["A", "B", "C"] and ["A", "C"] 259s returns ["B"] 259s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 259s returns ["A", "C", "D"] 259s #- 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns [] 259s for ["A", "B", "C"] and ["B"] 259s returns ["A", "C"] 259s for ["A", "B", "C"] and ["A", "C"] 259s returns ["B"] 259s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 259s returns ["A", "C", "D"] 259s 259s Immutable::SortedSet 259s #disjoint? 259s for [] and [] 259s returns true 259s for ["A"] and [] 259s returns true 259s for [] and ["A"] 259s returns true 259s for ["A"] and ["A"] 259s returns false 259s for ["A", "B", "C"] and ["B"] 259s returns false 259s for ["B"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["D", "E"] 259s returns true 259s for ["F", "G", "H", "I"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns false 259s for ["D", "E", "F", "G"] and ["A", "B", "C"] 259s returns true 259s 259s Immutable::SortedSet 259s #drop 259s 0 from [] 259s preserves the original 259s returns [] 259s 10 from [] 259s preserves the original 259s returns [] 259s 10 from ["A"] 259s preserves the original 259s returns [] 259s 0 from ["A", "B", "C"] 259s preserves the original 259s returns ["A", "B", "C"] 259s 1 from ["A", "B", "C"] 259s preserves the original 259s returns ["B", "C"] 259s 2 from ["A", "B", "C"] 259s preserves the original 259s returns ["C"] 259s 3 from ["A", "B", "C"] 259s preserves the original 259s returns [] 259s when argument is zero 259s returns self 259s when the set has a custom order 259s maintains the custom order 259s keeps the comparator even when set is cleared 259s when called on a subclass 259s should return an instance of the subclass 259s 259s Immutable::SortedSet 259s #drop_while 259s on [] 259s with a block 259s preserves the original 259s returns [] 259s without a block 259s returns an Enumerator 259s on ["A"] 259s with a block 259s preserves the original 259s returns [] 259s without a block 259s returns an Enumerator 259s on ["A", "B", "C"] 259s with a block 259s preserves the original 259s returns ["C"] 259s without a block 259s returns an Enumerator 259s on ["A", "B", "C", "D", "E", "F", "G"] 259s with a block 259s preserves the original 259s returns ["C", "D", "E", "F", "G"] 259s without a block 259s returns an Enumerator 259s 259s Immutable::SortedSet 259s #each 259s with no block 259s returns an Enumerator 259s with a block 259s returns self 259s iterates over the items in order 259s 259s Immutable::SortedSet 259s #empty? 259s on [] 259s returns true 259s on ["A"] 259s returns false 259s on ["A", "B", "C"] 259s returns false 259s .empty 259s returns the canonical empty set 259s from a subclass 259s returns an empty instance of the subclass 259s 259s Immutable::SortedSet 259s #eql? 259s when comparing to a standard set 259s returns false 259s when comparing to a arbitrary object 259s returns false 259s when comparing to an Immutable::Set 259s returns false 259s when comparing with a subclass of Immutable::SortedSet 259s returns false 259s with an empty set for each comparison 259s returns true 259s with an empty set and a set with nil 259s returns false 259s with a single item array and empty array 259s returns false 259s with matching single item array 259s returns true 259s with mismatching single item array 259s returns false 259s with a multi-item array and single item array 259s returns false 259s with matching multi-item array 259s returns true 259s with a mismatching multi-item array 259s returns true 259s with the same values, but a different sort order 259s returns false 259s 259s Immutable::SortedSet 259s #exclusion 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns [] 259s for ["A", "B", "C"] and ["B"] 259s returns ["A", "C"] 259s for ["A", "B", "C"] and ["B", "C", "D"] 259s returns ["A", "D"] 259s for ["A", "B", "C"] and ["D", "E", "F"] 259s returns ["A", "B", "C", "D", "E", "F"] 259s #^ 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns [] 259s for ["A", "B", "C"] and ["B"] 259s returns ["A", "C"] 259s for ["A", "B", "C"] and ["B", "C", "D"] 259s returns ["A", "D"] 259s for ["A", "B", "C"] and ["D", "E", "F"] 259s returns ["A", "B", "C", "D", "E", "F"] 259s 259s Immutable::SortedSet 259s #fetch 259s gives precedence to default block over default argument if passed both 259s with no default provided 259s when the index exists 259s returns the value at the index 259s when the key does not exist 259s raises an IndexError 259s with a default value 259s when the index exists 259s returns the value at the index 259s when the index does not exist 259s returns the default value 259s with a default block 259s when the index exists 259s returns the value at the index 259s when the index does not exist 259s invokes the block with the missing index as parameter 259s 259s Immutable::SortedSet 259s #find_index 259s looking for "A" in [] without block 259s returns nil 259s looking for "A" in [] with block 259s returns nil 259s looking for nil in [] with block 259s returns nil 259s looking for "A" in ["A"] without block 259s returns 0 259s looking for "A" in ["A"] with block 259s returns 0 259s looking for "B" in ["A"] without block 259s returns nil 259s looking for "B" in ["A"] with block 259s returns nil 259s looking for nil in ["A"] with block 259s returns nil 259s looking for "A" in ["A", "B", "C"] without block 259s returns 0 259s looking for "A" in ["A", "B", "C"] with block 259s returns 0 259s looking for "B" in ["A", "B", "C"] without block 259s returns 1 259s looking for "B" in ["A", "B", "C"] with block 259s returns 1 259s looking for "C" in ["A", "B", "C"] without block 259s returns 2 259s looking for "C" in ["A", "B", "C"] with block 259s returns 2 259s looking for "D" in ["A", "B", "C"] without block 259s returns nil 259s looking for "D" in ["A", "B", "C"] with block 259s returns nil 259s looking for 1 in 0..1 without block 259s returns 1 259s looking for 1 in 0..1 with block 259s returns 1 259s looking for 5 in 0..10 without block 259s returns 5 259s looking for 5 in 0..10 with block 259s returns 5 259s looking for 10 in 0..10 without block 259s returns 10 259s looking for 10 in 0..10 with block 259s returns 10 259s looking for 2 in [2] without block 259s returns 0 259s looking for 2 in [2] with block 259s returns 0 259s looking for 2.0 in [2] without block 259s returns 0 259s looking for 2.0 in [2] with block 259s returns 0 259s looking for 2.0 in [2.0] without block 259s returns 0 259s looking for 2.0 in [2.0] with block 259s returns 0 259s looking for 2 in [2.0] without block 259s returns 0 259s looking for 2 in [2.0] with block 259s returns 0 259s #index 259s looking for "A" in [] without block 259s returns nil 259s looking for "A" in [] with block 259s returns nil 259s looking for nil in [] with block 259s returns nil 259s looking for "A" in ["A"] without block 259s returns 0 259s looking for "A" in ["A"] with block 259s returns 0 259s looking for "B" in ["A"] without block 259s returns nil 259s looking for "B" in ["A"] with block 259s returns nil 259s looking for nil in ["A"] with block 259s returns nil 259s looking for "A" in ["A", "B", "C"] without block 259s returns 0 259s looking for "A" in ["A", "B", "C"] with block 259s returns 0 259s looking for "B" in ["A", "B", "C"] without block 259s returns 1 259s looking for "B" in ["A", "B", "C"] with block 259s returns 1 259s looking for "C" in ["A", "B", "C"] without block 259s returns 2 259s looking for "C" in ["A", "B", "C"] with block 259s returns 2 259s looking for "D" in ["A", "B", "C"] without block 259s returns nil 259s looking for "D" in ["A", "B", "C"] with block 259s returns nil 259s looking for 1 in 0..1 without block 259s returns 1 259s looking for 1 in 0..1 with block 259s returns 1 259s looking for 5 in 0..10 without block 259s returns 5 259s looking for 5 in 0..10 with block 259s returns 5 259s looking for 10 in 0..10 without block 259s returns 10 259s looking for 10 in 0..10 with block 259s returns 10 259s looking for 2 in [2] without block 259s returns 0 259s looking for 2 in [2] with block 259s returns 0 259s looking for 2.0 in [2] without block 259s returns 0 259s looking for 2.0 in [2] with block 259s returns 0 259s looking for 2.0 in [2.0] without block 259s returns 0 259s looking for 2.0 in [2.0] with block 259s returns 0 259s looking for 2 in [2.0] without block 259s returns 0 259s looking for 2 in [2.0] with block 259s returns 0 259s 259s Immutable::SortedSet 259s #first 259s on [] 259s returns nil 259s on ["A"] 259s returns "A" 259s on ["A", "B", "C"] 259s returns "A" 259s on ["Z", "Y", "X"] 259s returns "X" 259s 259s Immutable::SortedSet 259s #from 259s when called without a block 259s returns a sorted set of all items equal to or greater than the argument 259s when called with a block 259s yields all the items equal to or greater than than the argument 259s on an empty set 259s returns an empty set 259s with an argument higher than all the values in the set 259s returns an empty set 259s 259s Immutable::SortedSet 259s #group_by 259s with a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1, 3], false=>Immutable::SortedSet[2, 4]}] 259s without a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1], 2=>Immutable::SortedSet[2], 3=>Immutable::SortedSet[3], 4=>Immutable::SortedSet[4]}] 259s from a subclass 259s returns an Hash whose values are instances of the subclass 259s #group 259s with a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1, 3], false=>Immutable::SortedSet[2, 4]}] 259s without a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1], 2=>Immutable::SortedSet[2], 3=>Immutable::SortedSet[3], 4=>Immutable::SortedSet[4]}] 259s from a subclass 259s returns an Hash whose values are instances of the subclass 259s #classify 259s with a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{true=>Immutable::SortedSet[1, 3], false=>Immutable::SortedSet[2, 4]}] 259s without a block 259s on [] 259s preserves the original 259s returns [] 259s on [1] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1]}] 259s on [1, 2, 3, 4] 259s preserves the original 259s returns [{1=>Immutable::SortedSet[1], 2=>Immutable::SortedSet[2], 3=>Immutable::SortedSet[3], 4=>Immutable::SortedSet[4]}] 259s from a subclass 259s returns an Hash whose values are instances of the subclass 259s 259s Immutable::SortedSet 259s #include? 259s returns true for an existing value (1) 259s returns true for an existing value (2) 259s returns true for an existing value (3) 259s returns true for an existing value (4.0) 259s returns false for a non-existing value 259s uses #<=> for equality 259s #member? 259s returns true for an existing value (1) 259s returns true for an existing value (2) 259s returns true for an existing value (3) 259s returns true for an existing value (4.0) 259s returns false for a non-existing value 259s uses #<=> for equality 259s 259s Immutable::SortedSet 259s #inspect 259s on [] 259s returns "Immutable::SortedSet[]" 259s returns a string which can be eval'd to get an equivalent set 259s on ["A"] 259s returns "Immutable::SortedSet[\"A\"]" 259s returns a string which can be eval'd to get an equivalent set 259s on ["C", "B", "A"] 259s returns "Immutable::SortedSet[\"A\", \"B\", \"C\"]" 259s returns a string which can be eval'd to get an equivalent set 259s from a subclass 259s returns a programmer-readable representation of the set contents 259s returns a string which can be eval'd to get an equivalent set 259s 259s Immutable::SortedSet 259s #intersect? 259s for [] and [] 259s returns false 259s for ["A"] and [] 259s returns false 259s for [] and ["A"] 259s returns false 259s for ["A"] and ["A"] 259s returns true 259s for ["A", "B", "C"] and ["B"] 259s returns true 259s for ["B"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["D", "E"] 259s returns false 259s for ["F", "G", "H", "I"] and ["A", "B", "C"] 259s returns false 259s for ["A", "B", "C"] and ["A", "B", "C"] 259s returns true 259s for ["A", "B", "C"] and ["A", "B", "C", "D"] 259s returns true 259s for ["D", "E", "F", "G"] and ["A", "B", "C"] 259s returns false 259s 259s Immutable::SortedSet 259s #intersection 259s for [] and [] 259s returns [] 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns [] 259s for [] and ["A"] 259s returns [] 259s for ["A"] and ["A"] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns ["A"] 259s for ["A", "B", "C"] and ["B"] 259s returns ["B"] 259s for ["B"] and ["A", "B", "C"] 259s returns ["B"] 259s for ["A", "B", "C"] and ["A", "C"] 259s returns ["A", "C"] 259s for ["A", "C"] and ["A", "B", "C"] 259s returns ["A", "C"] 259s for ["A", "M", "T", "X"] and ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] 259s returns ["M", "T"] 259s for ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] and ["A", "M", "T", "X"] 259s returns ["M", "T"] 259s #& 259s for [] and [] 259s returns [] 259s for [] and [] 259s returns [] 259s for ["A"] and [] 259s returns [] 259s for [] and ["A"] 259s returns [] 259s for ["A"] and ["A"] 259s returns ["A"] 259s for ["A"] and ["A"] 259s returns ["A"] 259s for ["A", "B", "C"] and ["B"] 259s returns ["B"] 259s for ["B"] and ["A", "B", "C"] 259s returns ["B"] 259s for ["A", "B", "C"] and ["A", "C"] 259s returns ["A", "C"] 259s for ["A", "C"] and ["A", "B", "C"] 259s returns ["A", "C"] 259s for ["A", "M", "T", "X"] and ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] 259s returns ["M", "T"] 259s for ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] and ["A", "M", "T", "X"] 259s returns ["M", "T"] 259s 259s Immutable::SortedSet 259s #last 259s with an empty set 259s returns the last item 259s with a single item set 259s returns the last item 259s with a multi-item set 259s returns the last item 259s 259s Immutable::SortedSet 259s #map 259s when empty 259s returns self 259s when not empty 259s with a block 259s preserves the original values 259s returns a new set with the mapped values 259s filters out duplicates 259s with no block 259s returns an Enumerator 259s on a set ordered by a comparator 259s returns a new set with the mapped values 259s filters out duplicates 259s #collect 259s when empty 259s returns self 259s when not empty 259s with a block 259s preserves the original values 259s returns a new set with the mapped values 259s filters out duplicates 259s with no block 259s returns an Enumerator 259s on a set ordered by a comparator 259s returns a new set with the mapped values 259s filters out duplicates 259s 259s Immutable::SortedSet 259s #marshal_dump/#marshal_load 260s can survive dumping and loading into a new process 260s is still possible to find items by index after loading 260s raises a TypeError if set has a custom sort order 260s 260s Immutable::SortedSet 260s #max 260s with a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "Ichi" 260s without a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "San" 260s 260s Immutable::SortedSet 260s #min 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "Ichi" 260s on [1, 2, 3, 4, 5] 260s returns 1 260s on [0, -0.0, 2.2, -4, -4.2] 260s returns -4.2 260s 260s Immutable::SortedSet 260s .new 260s accepts a single enumerable argument and creates a new sorted set 260s also works with a Range 260s doesn't mutate the initializer 260s doesn't change if the initializer is later mutated 260s is amenable to overriding of #initialize 260s accepts a block with arity 1 260s accepts a block with arity 2 260s can use a block produced by Symbol#to_proc 260s filters out duplicates 260s when passed a comparator with arity 2 260s still filters out duplicates 260s still doesn't mutate the initializer 260s still doesn't change if the initializer is later mutated 260s when passed a block with arity 1 260s still filters out duplicates 260s still doesn't mutate the initializer 260s still doesn't change if the initializer is later mutated 260s from a subclass 260s returns a frozen instance of the subclass 260s .[] 260s accepts a variable number of items and creates a new sorted set 260s filters out duplicate items 260s 260s Immutable::SortedSet 260s #reverse_each 260s with no block 260s returns an Enumerator 260s with a block 260s returns self 260s iterates over the items in order 260s 260s Immutable::SortedSet 260s #sample 260s returns a randomly chosen item 260s 260s Immutable::SortedSet 260s #select 260s when everything matches 260s preserves the original 260s returns self 260s when only some things match 260s with a block 260s preserves the original 260s returns a set with the matching values 260s with no block 260s returns an Enumerator 260s when nothing matches 260s preserves the original 260s returns the canonical empty set 260s from a subclass 260s returns an instance of the same class 260s #find_all 260s when everything matches 260s preserves the original 260s returns self 260s when only some things match 260s with a block 260s preserves the original 260s returns a set with the matching values 260s with no block 260s returns an Enumerator 260s when nothing matches 260s preserves the original 260s returns the canonical empty set 260s from a subclass 260s returns an instance of the same class 260s 260s Immutable::SortedSet 260s #size 260s returns 0 for [] 260s returns 1 for ["A"] 260s returns 3 for ["A", "B", "C"] 260s #length 260s returns 0 for [] 261s returns 1 for ["A"] 261s returns 3 for ["A", "B", "C"] 261s 261s Immutable::SortedSet 261s #slice 261s when passed a positive integral index 261s returns the element at that index 261s leaves the original unchanged 261s when passed a negative integral index 261s returns the element which is number (index.abs) counting from the end of the sorted_set 261s when passed a positive integral index and count 261s returns 'count' elements starting from 'index' 261s leaves the original unchanged 261s when passed a negative integral index and count 261s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 261s when passed a Range 261s returns the elements whose indexes are within the given Range 261s leaves the original unchanged 261s when passed an empty Range 261s does not lose custom sort order 261s when passed a length of zero 261s does not lose custom sort order 261s when passed a subclass of Range 261s works the same as with a Range 261s on a subclass of SortedSet 261s with index and count or a range, returns an instance of the subclass 261s #[] 261s when passed a positive integral index 261s returns the element at that index 261s leaves the original unchanged 261s when passed a negative integral index 261s returns the element which is number (index.abs) counting from the end of the sorted_set 261s when passed a positive integral index and count 261s returns 'count' elements starting from 'index' 261s leaves the original unchanged 261s when passed a negative integral index and count 261s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 261s when passed a Range 261s returns the elements whose indexes are within the given Range 261s leaves the original unchanged 261s when passed an empty Range 261s does not lose custom sort order 261s when passed a length of zero 261s does not lose custom sort order 261s when passed a subclass of Range 261s works the same as with a Range 261s on a subclass of SortedSet 261s with index and count or a range, returns an instance of the subclass 261s 261s Immutable::SortedSet 261s #sort 261s on [] 261s with a block 261s preserves the original 261s returns [] 261s without a block 261s preserves the original 261s returns [] 261s on ["A"] 261s with a block 261s preserves the original 261s returns ["A"] 261s without a block 261s preserves the original 261s returns ["A"] 261s on ["Ichi", "Ni", "San"] 261s with a block 261s preserves the original 261s returns ["Ni", "San", "Ichi"] 261s without a block 261s preserves the original 261s returns ["Ichi", "Ni", "San"] 261s #sort_by 261s on [] 261s with a block 261s preserves the original 261s returns [] 261s without a block 261s preserves the original 261s returns [] 261s on ["A"] 261s with a block 261s preserves the original 261s returns ["A"] 261s without a block 261s preserves the original 261s returns ["A"] 261s on ["Ichi", "Ni", "San"] 261s with a block 261s preserves the original 261s returns ["Ni", "San", "Ichi"] 261s without a block 261s preserves the original 261s returns ["Ichi", "Ni", "San"] 261s sort 261s on a SortedSet with custom sort order 261s returns a SortedSet with the natural sort order 261s 261s Immutable::SortedSet 261s #subset? 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s #proper_subset? 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s 261s Immutable::SortedSet 261s #superset? 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s #proper_superset? 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s 261s Immutable::SortedSet 261s #take 261s 10 from [] 261s preserves the original 261s returns [] 261s 10 from ["A"] 261s preserves the original 261s returns ["A"] 261s 0 from ["A", "B", "C"] 261s preserves the original 261s returns [] 261s 2 from ["A", "B", "C"] 261s preserves the original 261s returns ["A", "B"] 261s when argument is at least size of receiver 261s returns self 261s when the set has a custom order 261s maintains the custom order 261s keeps the comparator even when set is cleared 261s when called on a subclass 261s should return an instance of the subclass 261s 261s Immutable::SortedSet 261s #take_while 261s on [] 261s with a block 261s returns [] 261s preserves the original 261s without a block 261s returns an Enumerator 261s on ["A"] 261s with a block 261s returns ["A"] 261s preserves the original 261s without a block 261s returns an Enumerator 261s on ["A", "B", "C"] 261s with a block 261s returns ["A", "B"] 261s preserves the original 261s without a block 261s returns an Enumerator 261s 261s Immutable::SortedSet 261s #to_set 261s on [] 261s returns a set with the same values 261s on ["A"] 261s returns a set with the same values 261s on ["A", "B", "C"] 261s returns a set with the same values 261s 261s Immutable::SortedSet 261s #union 261s for [] and [] 261s returns [] 261s for [] and [] 261s returns [] 261s for ["A"] and [] 261s returns ["A"] 261s for [] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"] 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"] 261s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s #| 261s for [] and [] 261s returns [] 261s for [] and [] 261s returns [] 261s for ["A"] and [] 261s returns ["A"] 261s for [] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"] 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"] 261s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s #+ 261s for [] and [] 261s returns [] 261s for [] and [] 261s returns [] 261s for ["A"] and [] 261s returns ["A"] 261s for [] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"] 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"] 261s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s #merge 261s for [] and [] 261s returns [] 261s for [] and [] 261s returns [] 261s for ["A"] and [] 261s returns ["A"] 261s for [] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A"] and ["A"] 261s returns ["A"] 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"] 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"] 261s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 261s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 261s union 261s filters out duplicates when passed an Array 261s doesn't mutate an Array which is passed in 261s on a set ordered by a comparator 261s still filters out duplicates when passed an Array 261s still doesn't mutate an Array which is passed in 261s 261s Immutable::SortedSet 261s #up_to 261s when called without a block 261s returns a sorted set of all items equal to or less than the argument 261s when called with a block 261s yields all the items equal to or less than than the argument 261s on an empty set 261s returns an empty set 261s with an argument less than all the values in the set 261s returns an empty set 261s 261s Immutable::SortedSet 261s .uniq_by_comparator! 261s can handle empty arrays 261s can handle arrays with 1 element 261s can handle arrays with 2 elements and no dupes 261s can handle arrays with 2 elements and dupes 261s can handle arrays with lots of elements 261s works with funny comparators 261s 261s Immutable::SortedSet 261s #values_at 261s accepts any number of indices, and returns a sorted_set of items at those indices 261s when passed invalid indices 261s filters them out 261s when passed no arguments 261s returns an empty sorted_set 261s from a subclass 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #add 261s with a empty vector adding a single item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a duplicate item 261s preserves the original 261s adds the item to the vector 261s with a 31-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 32-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 33-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1023-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1024-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1025-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s from a subclass 261s returns an instance of the subclass 261s #<< 261s with a empty vector adding a single item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a duplicate item 261s preserves the original 261s adds the item to the vector 261s with a 31-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 32-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 33-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1023-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1024-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1025-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s from a subclass 261s returns an instance of the subclass 261s #push 261s with a empty vector adding a single item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a single-item vector adding a duplicate item 261s preserves the original 261s adds the item to the vector 261s with a 31-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 32-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 33-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1023-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1024-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s with a 1025-item vector adding a different item 261s preserves the original 261s adds the item to the vector 261s from a subclass 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #any? 261s when created with no values 261s with a block 261s returns false 261s with a block 261s returns false 261s when created with values 261s with a block that returns true 261s returns true 261s with a block that doesn't return true 261s returns false 261s without a block 261s with some values that are truthy 261s returns true 261s with all values that are falsey 261s returns false 261s 261s Immutable::Vector 261s #assoc 261s searches for a 2-element array with a given 1st item 261s returns nil if a matching 1st item is not found 261s uses #== to compare 1st items with provided object 261s skips elements which are not indexable 261s #rassoc 261s searches for a 2-element array with a given 2nd item 261s returns nil if a matching 2nd item is not found 261s uses #== to compare 2nd items with provided object 261s skips elements which are not indexable 261s 261s Immutable::Vector 261s #bsearch 261s with a block which returns false for elements below desired position, and true for those at/above 261s returns the first element for which the predicate is true 261s if the block always returns false 261s returns nil 261s if the block always returns true 261s returns the first element 261s with a block which returns a negative number for elements below desired position, zero for the right element, and positive for those above 261s returns the element for which the block returns zero 261s if the block always returns positive 261s returns nil 261s if the block always returns negative 261s returns nil 261s if the block returns sometimes positive, sometimes negative, but never zero 261s returns nil 261s if not passed a block 261s returns an Enumerator 261s on an empty vector 261s returns nil 261s 261s Immutable::Vector 261s #clear 261s on [] 261s preserves the original 261s returns an empty vector 261s from a subclass 261s returns an instance of the subclass 261s on ["A"] 261s preserves the original 261s returns an empty vector 261s from a subclass 261s returns an instance of the subclass 261s on ["A", "B", "C"] 261s preserves the original 261s returns an empty vector 261s from a subclass 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #combination 261s works on many combinations of input 261s leaves the original unmodified 261s with a block 261s returns self 261s with no block 261s returns an Enumerator 261s when passed an argument which is out of bounds 261s yields nothing and returns self 261s when passed an argument zero 261s yields an empty array 261s when passed an argument equal to the vector's length 261s yields self as an array 261s when passed an argument 1 261s yields each item in the vector, as single-item vectors 261s when passed another integral argument 261s yields all combinations of the given length 261s on an empty vector 261s works the same 261s 261s Immutable::Vector 261s #compact 261s returns a new Vector with all nils removed 261s doesn't remove false 261s on an empty vector 261s returns self 261s from a subclass 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #<=> 261s with [] and [1] 261s returns -1 261s with [1] and [] 261s returns 1 261s with [] and [] 261s returns 0 261s with [1] and [2] 261s returns -1 261s with [2] and [1] 261s returns 1 261s with [1] and [1] 261s returns 0 261s with [1] and [1, 2] 261s returns -1 261s with [1, 2] and [1] 261s returns 1 261s with [1] and [1] 261s returns 0 261s with [2, 3, 4] and [3, 4, 5] 261s returns -1 261s with [3, 4, 5] and [2, 3, 4] 261s returns 1 261s with [2, 3, 4] and [2, 3, 4] 261s returns 0 261s with [[0]] and [[1]] 261s returns -1 261s with [[1]] and [[0]] 261s returns 1 261s with [[0]] and [[0]] 261s returns 0 261s 261s Immutable::Vector 261s #+ 261s preserves the original 261s appends the elements in the other enumerable 261s on a 1-item vector 261s works the same 261s on a 31-item vector 261s works the same 261s on a 32-item vector 261s works the same 261s on a 33-item vector 261s works the same 261s on a 1023-item vector 261s works the same 261s on a 1024-item vector 261s works the same 261s on a 1025-item vector 261s works the same 261s #concat 261s preserves the original 261s appends the elements in the other enumerable 261s on a 1-item vector 261s works the same 261s on a 31-item vector 261s works the same 261s on a 32-item vector 261s works the same 261s on a 33-item vector 261s works the same 261s on a 1023-item vector 261s works the same 261s on a 1024-item vector 261s works the same 261s on a 1025-item vector 261s works the same 261s 261s Immutable::Vector 261s on [] 261s returns self 261s on ["A"] 261s returns self 261s on ["A", "B", "C"] 261s returns self 261s on 1..32 261s returns self 261s on [] 261s returns self 261s on ["A"] 261s returns self 261s on ["A", "B", "C"] 261s returns self 261s on 1..32 261s returns self 261s 261s Immutable::Vector 261s #count 261s returns the number of elements 261s returns the number of elements that equal the argument 261s returns the number of element for which the block evaluates to true 261s 261s Immutable::Vector 261s #delete_at 261s removes the element at the specified index 261s makes no modification if the index is out of range 261s works when deleting last item at boundary where vector trie needs to get shallower 261s works on an empty vector 261s works on a vector with 1 item 261s works on a vector with 32 items 261s has the right size and contents after many deletions 261s 261s Immutable::Vector 261s #delete 261s removes elements that are #== to the argument 261s on an empty vector 261s returns self 261s on a subclass of Vector 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #dig 261s returns value at the index with one argument 261s returns value at index in nested arrays 261s raises an error when indexing deeper than possible 261s returns nil if you index past the end of an array 261s raises an error when indexing with a key vectors don't understand 261s 261s Immutable::Vector 261s #drop 261s raises an ArgumentError if number of elements specified is negative 261s 10 from [] 261s preserves the original 261s returns [] 261s 10 from ["A"] 261s preserves the original 261s returns [] 261s 1 from ["A"] 261s preserves the original 261s returns [] 261s 0 from ["A"] 261s preserves the original 261s returns ["A"] 261s 0 from ["A", "B", "C"] 261s preserves the original 261s returns ["A", "B", "C"] 261s 2 from ["A", "B", "C"] 261s preserves the original 261s returns ["C"] 261s 3 from 1..32 261s preserves the original 261s returns 4..32 261s 32 from 1..33 261s preserves the original 261s returns [33] 261s when number of elements specified is zero 261s returns self 261s 261s Immutable::Vector 261s #drop_while 261s returns an empty vector if block is always true 261s stops dropping items if block returns nil 261s stops dropping items if block returns false 261s on [] 261s with a block 261s preserves the original 261s returns [] 261s without a block 261s returns an Enumerator 261s on ["A"] 261s with a block 261s preserves the original 261s returns [] 261s without a block 261s returns an Enumerator 261s on ["A", "B", "C"] 261s with a block 261s preserves the original 261s returns ["C"] 261s without a block 261s returns an Enumerator 261s on an empty vector 261s returns an empty vector 261s 261s Immutable::Vector 261s #each_index 261s with a block 261s yields all the valid indices into the vector 261s returns self 261s without a block 261s returns an Enumerator 261s on an empty vector 261s doesn't yield anything 261s on a 1-item vector 261s yields all valid indices 261s on a 2-item vector 261s yields all valid indices 261s on a 10-item vector 261s yields all valid indices 261s on a 31-item vector 261s yields all valid indices 261s on a 32-item vector 261s yields all valid indices 261s on a 33-item vector 261s yields all valid indices 261s on a 1000-item vector 261s yields all valid indices 261s on a 1024-item vector 261s yields all valid indices 261s on a 1025-item vector 261s yields all valid indices 261s 261s Immutable::Vector 261s #each 261s with no block 261s returns an Enumerator 261s on a 31-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on a 32-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on a 33-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on a 1023-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on a 1024-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on a 1025-item vector 261s with a block 261s returns self 261s yields all the items 261s iterates over the items in order 261s on an empty vector 261s doesn't yield anything 261s 261s Immutable::Vector 261s #each_with_index 261s with no block 261s returns an Enumerator 261s on a 1-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 2-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 31-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 32-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 33-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 1023-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 1024-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on a 1025-item vector 261s with a block 261s returns self 261s iterates over the items in order 261s on an empty vector 261s doesn't yield anything 261s 261s Immutable::Vector 261s #empty? 261s on [] 261s returns true 261s on ["A"] 261s returns false 261s on ["A", "B", "C"] 261s returns false 261s .empty 261s returns the canonical empty vector 261s from a subclass 261s returns an empty instance of the subclass 261s calls overridden #initialize when creating empty Hash 261s 261s Immutable::Vector 261s #eql 261s returns false when comparing with an array with the same contents 261s returns false when comparing with an arbitrary object 261s returns false when comparing an empty vector with an empty array 261s returns false when comparing with a subclass of Immutable::Vector 261s #== 261s returns true when comparing with an array with the same contents 261s returns false when comparing with an arbitrary object 261s returns true when comparing an empty vector with an empty array 261s returns true when comparing with a subclass of Immutable::Vector 261s works on larger vectors 261s #eql? 261s returns true 261s for vectors [] and [] 261s for vectors [] and [] 261s returns false 261s for vectors [] and [nil] 261s for vectors [nil] and [] 261s returns false 261s for vectors ["A"] and [] 261s for vectors [] and ["A"] 261s returns true 261s for vectors ["A"] and ["A"] 261s for vectors ["A"] and ["A"] 261s returns false 261s for vectors ["A"] and ["B"] 261s for vectors ["B"] and ["A"] 261s returns false 261s for vectors ["A", "B"] and ["A"] 261s for vectors ["A"] and ["A", "B"] 261s returns true 261s for vectors ["A", "B", "C"] and ["A", "B", "C"] 261s for vectors ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for vectors ["C", "A", "B"] and ["A", "B", "C"] 261s for vectors ["A", "B", "C"] and ["C", "A", "B"] 261s #== 261s returns true 261s for vectors [] and [] 261s for vectors [] and [] 261s returns false 261s for vectors [] and [nil] 261s for vectors [nil] and [] 261s returns false 261s for vectors ["A"] and [] 261s for vectors [] and ["A"] 261s returns true 261s for vectors ["A"] and ["A"] 261s for vectors ["A"] and ["A"] 261s returns false 261s for vectors ["A"] and ["B"] 261s for vectors ["B"] and ["A"] 261s returns false 261s for vectors ["A", "B"] and ["A"] 261s for vectors ["A"] and ["A", "B"] 261s returns true 261s for vectors ["A", "B", "C"] and ["A", "B", "C"] 261s for vectors ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for vectors ["C", "A", "B"] and ["A", "B", "C"] 261s for vectors ["A", "B", "C"] and ["C", "A", "B"] 261s 261s Immutable::Vector 261s #fetch 261s gives precedence to default block over default argument if passed both 261s with no default provided 261s when the index exists 261s returns the value at the index 261s when the key does not exist 261s raises an IndexError 261s with a default value 261s when the index exists 261s returns the value at the index 261s when the index does not exist 261s returns the default value 261s with a default block 261s when the index exists 261s returns the value at the index 261s when the index does not exist 261s invokes the block with the missing index as parameter 261s 261s Immutable::Vector 261s #fill 261s can replace a range of items at the beginning of a vector 261s can replace a range of items in the middle of a vector 261s can replace a range of items at the end of a vector 261s can replace all the items in a vector 261s can fill past the end of the vector 261s behaves like Array#fill, on a variety of inputs 261s with 1 argument 261s replaces all the items in the vector by default 261s with 2 arguments 261s replaces up to the end of the vector by default 261s when index and length are 0 261s leaves the vector unmodified 261s when expanding a vector past boundary where vector trie needs to deepen 261s works the same 261s on a 1000-item vector 261s works the same 261s on a 1023-item vector 261s works the same 261s on a 1024-item vector 261s works the same 261s on a 1025-item vector 261s works the same 261s on a 2000-item vector 261s works the same 261s 261s Immutable::Vector 261s #first 261s on [] 261s returns nil 261s on ["A"] 261s returns "A" 261s on ["A", "B", "C"] 261s returns "A" 261s on 1..32 261s returns 1 261s 261s Immutable::Vector 261s #flat_map 261s with an empty vector 261s returns the flattened values as an Immutable::Vector 261s returns an Immutable::Vector 261s with a block that returns an empty vector 261s returns the flattened values as an Immutable::Vector 261s returns an Immutable::Vector 261s with a vector of one item 261s returns the flattened values as an Immutable::Vector 261s returns an Immutable::Vector 261s with a vector of multiple items 261s returns the flattened values as an Immutable::Vector 261s returns an Immutable::Vector 261s 261s Immutable::Vector 261s #flatten 261s recursively flattens nested vectors into containing vector 261s flattens nested arrays as well 261s leaves the original unmodified 261s with an integral argument 261s only flattens down to the specified depth 261s with an argument of zero 261s returns self 261s on a subclass 261s returns an instance of the subclass 261s on a vector with no nested vectors 261s returns an unchanged vector 261s on a Vector larger than 32 items initialized with Vector.new 261s returns an unchanged vector 261s 261s Immutable::Vector 261s #get 261s when empty 261s always returns nil 261s when not empty 261s with a positive index 261s within the absolute bounds of the vector 261s returns the value at the specified index from the head 261s outside the absolute bounds of the vector 261s returns nil 261s with a negative index 261s within the absolute bounds of the vector 261s returns the value at the specified index from the tail 261s outside the absolute bounds of the vector 261s returns nil 261s on a 1-item vector 261s works correctly, even after various addings and removings 261s on a 10-item vector 261s works correctly, even after various addings and removings 261s on a 31-item vector 261s works correctly, even after various addings and removings 261s on a 32-item vector 261s works correctly, even after various addings and removings 261s on a 33-item vector 261s works correctly, even after various addings and removings 261s on a 1024-item vector 261s works correctly, even after various addings and removings 261s on a 1025-item vector 261s works correctly, even after various addings and removings 261s on a 2000-item vector 261s works correctly, even after various addings and removings 261s #at 261s when empty 261s always returns nil 261s when not empty 261s with a positive index 261s within the absolute bounds of the vector 261s returns the value at the specified index from the head 261s outside the absolute bounds of the vector 261s returns nil 261s with a negative index 261s within the absolute bounds of the vector 261s returns the value at the specified index from the tail 261s outside the absolute bounds of the vector 261s returns nil 261s on a 1-item vector 261s works correctly, even after various addings and removings 261s on a 10-item vector 261s works correctly, even after various addings and removings 261s on a 31-item vector 261s works correctly, even after various addings and removings 261s on a 32-item vector 261s works correctly, even after various addings and removings 261s on a 33-item vector 261s works correctly, even after various addings and removings 261s on a 1024-item vector 261s works correctly, even after various addings and removings 261s on a 1025-item vector 261s works correctly, even after various addings and removings 261s on a 2000-item vector 261s works correctly, even after various addings and removings 261s 261s Immutable::Vector 261s #group_by 261s returns a hash without default proc 261s with a block 261s on [] 261s returns [] 261s on [1] 261s returns [{true=>Immutable::Vector[1]}] 261s on [1, 2, 3, 4] 261s returns [{true=>Immutable::Vector[1, 3], false=>Immutable::Vector[2, 4]}] 261s without a block 261s on [] 261s returns [] 261s on [1] 261s returns [{1=>Immutable::Vector[1]}] 261s on [1, 2, 3, 4] 261s returns [{1=>Immutable::Vector[1], 2=>Immutable::Vector[2], 3=>Immutable::Vector[3], 4=>Immutable::Vector[4]}] 261s on an empty vector 261s returns an empty hash 261s from a subclass 261s returns an Hash whose values are instances of the subclass 261s 261s Immutable::Vector 261s #include? 261s on [] 261s returns false 261s on [] 261s returns false 261s on ["A"] 261s returns true 261s on ["A"] 261s returns false 261s on ["A"] 261s returns false 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns false 261s on ["A", "B", false] 261s returns true 261s on [2] 261s returns true 261s on [2] 261s returns true 261s on [2.0] 261s returns true 261s on [2.0] 261s returns true 261s #member? 261s on [] 261s returns false 261s on [] 261s returns false 261s on ["A"] 261s returns true 261s on ["A"] 261s returns false 261s on ["A"] 261s returns false 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns true 261s on ["A", "B", nil] 261s returns false 261s on ["A", "B", false] 261s returns true 261s on [2] 261s returns true 261s on [2] 261s returns true 261s on [2.0] 261s returns true 261s on [2.0] 261s returns true 261s 261s Immutable::Vector 261s #insert 261s can add items at the beginning of a vector 261s can add items in the middle of a vector 261s can add items at the end of a vector 261s can add items past the end of a vector 261s accepts a negative index, which counts back from the end of the vector 261s raises IndexError if a negative index is too great 261s works when adding an item past boundary when vector trie needs to deepen 261s works when adding to an empty Vector 261s has the right size and contents after many insertions 261s 261s Immutable::Vector 261s #inspect 261s with an empty array 261s returns its contents as a programmer-readable string 261s returns a string which can be eval'd to get back an equivalent vector 261s with a single item array 261s returns its contents as a programmer-readable string 261s returns a string which can be eval'd to get back an equivalent vector 261s with a multi-item array 261s returns its contents as a programmer-readable string 261s returns a string which can be eval'd to get back an equivalent vector 261s from a subclass 261s returns its contents as a programmer-readable string 261s returns a string which can be eval'd to get back an equivalent vector 261s 261s Immutable::Vector 261s #join 261s with a separator 261s on [] 261s preserves the original 261s returns "" 261s on ["A"] 261s preserves the original 261s returns "A" 261s on ["A", "B", "C"] 261s preserves the original 261s returns "A|B|C" 261s without a separator 261s on [] 261s preserves the original 261s returns "" 261s on ["A"] 261s preserves the original 261s returns "A" 261s on ["A", "B", "C"] 261s preserves the original 261s returns "ABC" 261s without a separator (with global default separator set) 261s on ["A", "B", "C"] 261s returns "A**B**C" 261s 261s Immutable::Vector 261s #last 261s with an empty vector 261s returns the last item 261s with a single item vector 261s returns the last item 261s with a multi-item vector 261s returns the last item 261s with a 31-item vector 261s returns the last item 261s with a 32-item vector 261s returns the last item 261s with a 33-item vector 261s returns the last item 261s with a 1023-item vector 261s returns the last item 261s with a 1024-item vector 261s returns the last item 261s with a 1025-item vector 261s returns the last item 261s 261s Immutable::Vector 261s #length 261s with an empty vector 261s returns the values 261s with a single item vector 261s returns the values 261s with a multi-item vector 261s returns the values 261s with a 31-item vector 261s returns the values 261s with a 32-item vector 261s returns the values 261s with a 33-item vector 261s returns the values 261s with a 1023-item vector 261s returns the values 261s with a 1024-item vector 261s returns the values 261s with a 1025-item vector 261s returns the values 261s 261s Immutable::Vector 261s #<< 261s with a empty array adding a single item 261s preserves the original 261s ltlts the item to the vector 261s with a single-item array adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a single-item array adding a duplicate item 261s preserves the original 261s ltlts the item to the vector 261s with a 31-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a 32-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a 33-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a 1023-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a 1024-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s with a 1025-item vector adding a different item 261s preserves the original 261s ltlts the item to the vector 261s from a subclass 261s returns an instance of the subclass 261s 261s Immutable::Vector 261s #map 261s when empty 261s returns self 261s when not empty 261s with a block 261s preserves the original values 261s returns a new vector with the mapped values 261s with no block 261s returns an Enumerator 261s from a subclass 261s returns an instance of the subclass 261s on a large vector 261s works 261s #collect 261s when empty 261s returns self 261s when not empty 261s with a block 261s preserves the original values 261s returns a new vector with the mapped values 261s with no block 261s returns an Enumerator 261s from a subclass 261s returns an instance of the subclass 261s on a large vector 261s works 261s 261s Immutable::Vector 261s #marshal_dump/#marshal_load 261s can survive dumping and loading into a new process 262s is still possible to find items by index after loading 262s 262s Immutable::Vector 262s #max 262s with a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "Ichi" 262s without a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "San" 262s 262s Immutable::Vector 262s #min 262s with a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "Ni" 262s without a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "Ichi" 262s 262s Immutable::Vector 262s #* 262s raises a TypeError if passed nil 262s raises an ArgumentError if passed no arguments 262s with a String argument 262s acts just like #join 262s with an Integer argument 262s concatenates n copies of the array 262s raises an ArgumentError if integer is negative 262s works on large vectors 262s with a subclass of Vector 262s returns an instance of the subclass 262s 262s Immutable::Vector 262s .new 262s accepts a single enumerable argument and creates a new vector 262s makes a defensive copy of a non-frozen mutable Array passed in 262s is amenable to overriding of #initialize 262s from a subclass 262s returns a frozen instance of the subclass 262s .[] 262s accepts a variable number of items and creates a new vector 262s 262s Immutable::Vector 262s #partition 262s on [] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [1] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [1, 2] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [1, 2, 3] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [1, 2, 3, 4] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [2, 3, 4] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [3, 4] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s on [4] 262s with a block 262s preserves the original 262s returns a frozen array with two items 262s correctly identifies the matches 262s correctly identifies the remainder 262s without a block 262s returns an Enumerator 262s 262s Immutable::Vector 262s #permutation 262s handles duplicate elements correctly 262s leaves the original unmodified 262s behaves like Array#permutation 262s without a block or arguments 262s returns an Enumerator of all permutations 262s without a block, but with integral argument 262s returns an Enumerator of all permutations of given length 262s with a block 262s returns self 262s and no argument 262s yields all permutations 262s and an integral argument 262s yields all permutations of the given length 262s on an empty vector 262s yields the empty permutation 262s with an argument of zero 262s yields the empty permutation 262s with a length greater than the size of the vector 262s yields no permutations 262s 262s Immutable::Vector 262s #pop 262s on [] 262s preserves the original 262s returns [] 262s on ["A"] 262s preserves the original 262s returns [] 262s on ["A", "B", "C"] 262s preserves the original 262s returns ["A", "B"] 262s on 1..32 262s preserves the original 262s returns 1..31 262s on 1..33 262s preserves the original 262s returns 1..32 262s 262s Immutable::Vector 262s #product 262s when passed no arguments 262s multiplies all items in vector 262s when passed one or more vectors 262s when passed a block 262s yields an array for each combination of items from the vectors 262s returns self 262s when not passed a block 262s returns the cartesian product in an array 262s when one of the arguments is empty 262s returns an empty array 262s when the receiver is empty 262s returns an empty array 262s when passed one or more Arrays 262s also calculates the cartesian product correctly 262s 262s Immutable::Vector 262s #reduce 262s on [] 262s with an initial value of 10 262s and a block 262s returns 10 262s on [1] 262s with an initial value of 10 262s and a block 262s returns 9 262s on [1, 2, 3] 262s with an initial value of 10 262s and a block 262s returns 4 262s on [] 262s with no initial value 262s and a block 262s returns nil 262s on [1] 262s with no initial value 262s and a block 262s returns 1 262s on [1, 2, 3] 262s with no initial value 262s and a block 262s returns -4 262s with no block and a symbol argument 262s uses the symbol as the name of a method to reduce with 262s with no block and a string argument 262s uses the string as the name of a method to reduce with 262s #inject 262s on [] 262s with an initial value of 10 262s and a block 262s returns 10 262s on [1] 262s with an initial value of 10 262s and a block 262s returns 9 262s on [1, 2, 3] 262s with an initial value of 10 262s and a block 262s returns 4 262s on [] 262s with no initial value 262s and a block 262s returns nil 262s on [1] 262s with no initial value 262s and a block 262s returns 1 262s on [1, 2, 3] 262s with no initial value 262s and a block 262s returns -4 262s with no block and a symbol argument 262s uses the symbol as the name of a method to reduce with 262s with no block and a string argument 262s uses the string as the name of a method to reduce with 262s 262s Immutable::Vector 262s #reject 262s works with a variety of inputs 262s on [] 262s with a block 262s returns [] 262s without a block 262s returns an Enumerator 262s on ["A"] 262s with a block 262s returns ["A"] 262s without a block 262s returns an Enumerator 262s on ["A", "B", "C"] 262s with a block 262s returns ["A", "B", "C"] 262s without a block 262s returns an Enumerator 262s on ["A", "b", "C"] 262s with a block 262s returns ["A", "C"] 262s without a block 262s returns an Enumerator 262s on ["a", "b", "c"] 262s with a block 262s returns [] 262s without a block 262s returns an Enumerator 262s #delete_if 262s works with a variety of inputs 262s on [] 262s with a block 262s returns [] 262s without a block 262s returns an Enumerator 262s on ["A"] 262s with a block 262s returns ["A"] 262s without a block 262s returns an Enumerator 262s on ["A", "B", "C"] 262s with a block 262s returns ["A", "B", "C"] 262s without a block 262s returns an Enumerator 262s on ["A", "b", "C"] 262s with a block 262s returns ["A", "C"] 262s without a block 262s returns an Enumerator 262s on ["a", "b", "c"] 262s with a block 262s returns [] 262s without a block 262s returns an Enumerator 262s 262s Immutable::Vector 262s #repeated_combination 262s leaves the original unmodified 262s behaves like Array#repeated_combination 262s with no block 262s returns an Enumerator 262s with a block 262s returns self 262s with a negative argument 262s yields nothing and returns self 262s with a zero argument 262s yields an empty array 262s with a argument of 1 262s yields each item in the vector, as single-item vectors 262s on an empty vector, with an argument greater than zero 262s yields nothing 262s with a positive argument, greater than 1 262s yields all combinations of the given size (where a single element can appear more than once in a row) 262s 262s Immutable::Vector 262s #repeated_permutation 262s handles duplicate elements correctly 262s allows permutations larger than the number of elements 262s leaves the original unmodified 262s behaves like Array#repeated_permutation 262s without a block 262s and without argument 262s returns an Enumerator of all repeated permutations 262s with an integral argument 262s returns an Enumerator of all repeated permutations of the given length 262s with a block 262s returns self 262s on an empty vector 262s yields the empty permutation 262s with an argument of zero 262s yields the empty permutation 262s with no argument 262s yields all repeated permutations 262s with a positive integral argument 262s yields all repeated permutations of the given length 262s 262s Immutable::Vector 262s #reverse_each 262s on a 2-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 31-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 32-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 33-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 1000-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 1024-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 1025-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s on a 2000-item vector 262s with a block (internal iteration) 262s returns self 262s yields all items in the opposite order as #each 262s with no block 262s returns an Enumerator 262s 262s Immutable::Vector 262s #reverse 262s on [] 262s returns [] 262s on [1] 262s returns [1] 262s on [1, 2] 262s returns [2, 1] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32] 262s returns [32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33] 262s returns [33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100] 262s returns [100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024] 262s returns [1024, 1023, 1022, 1021, 1020, 1019, 1018, 1017, 1016, 1015, 1014, 1013, 1012, 1011, 1010, 1009, 1008, 1007, 1006, 1005, 1004, 1003, 1002, 1001, 1000, 999, 998, 997, 996, 995, 994, 993, 992, 991, 990, 989, 988, 987, 986, 985, 984, 983, 982, 981, 980, 979, 978, 977, 976, 975, 974, 973, 972, 971, 970, 969, 968, 967, 966, 965, 964, 963, 962, 961, 960, 959, 958, 957, 956, 955, 954, 953, 952, 951, 950, 949, 948, 947, 946, 945, 944, 943, 942, 941, 940, 939, 938, 937, 936, 935, 934, 933, 932, 931, 930, 929, 928, 927, 926, 925, 924, 923, 922, 921, 920, 919, 918, 917, 916, 915, 914, 913, 912, 911, 910, 909, 908, 907, 906, 905, 904, 903, 902, 901, 900, 899, 898, 897, 896, 895, 894, 893, 892, 891, 890, 889, 888, 887, 886, 885, 884, 883, 882, 881, 880, 879, 878, 877, 876, 875, 874, 873, 872, 871, 870, 869, 868, 867, 866, 865, 864, 863, 862, 861, 860, 859, 858, 857, 856, 855, 854, 853, 852, 851, 850, 849, 848, 847, 846, 845, 844, 843, 842, 841, 840, 839, 838, 837, 836, 835, 834, 833, 832, 831, 830, 829, 828, 827, 826, 825, 824, 823, 822, 821, 820, 819, 818, 817, 816, 815, 814, 813, 812, 811, 810, 809, 808, 807, 806, 805, 804, 803, 802, 801, 800, 799, 798, 797, 796, 795, 794, 793, 792, 791, 790, 789, 788, 787, 786, 785, 784, 783, 782, 781, 780, 779, 778, 777, 776, 775, 774, 773, 772, 771, 770, 769, 768, 767, 766, 765, 764, 763, 762, 761, 760, 759, 758, 757, 756, 755, 754, 753, 752, 751, 750, 749, 748, 747, 746, 745, 744, 743, 742, 741, 740, 739, 738, 737, 736, 735, 734, 733, 732, 731, 730, 729, 728, 727, 726, 725, 724, 723, 722, 721, 720, 719, 718, 717, 716, 715, 714, 713, 712, 711, 710, 709, 708, 707, 706, 705, 704, 703, 702, 701, 700, 699, 698, 697, 696, 695, 694, 693, 692, 691, 690, 689, 688, 687, 686, 685, 684, 683, 682, 681, 680, 679, 678, 677, 676, 675, 674, 673, 672, 671, 670, 669, 668, 667, 666, 665, 664, 663, 662, 661, 660, 659, 658, 657, 656, 655, 654, 653, 652, 651, 650, 649, 648, 647, 646, 645, 644, 643, 642, 641, 640, 639, 638, 637, 636, 635, 634, 633, 632, 631, 630, 629, 628, 627, 626, 625, 624, 623, 622, 621, 620, 619, 618, 617, 616, 615, 614, 613, 612, 611, 610, 609, 608, 607, 606, 605, 604, 603, 602, 601, 600, 599, 598, 597, 596, 595, 594, 593, 592, 591, 590, 589, 588, 587, 586, 585, 584, 583, 582, 581, 580, 579, 578, 577, 576, 575, 574, 573, 572, 571, 570, 569, 568, 567, 566, 565, 564, 563, 562, 561, 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, 548, 547, 546, 545, 544, 543, 542, 541, 540, 539, 538, 537, 536, 535, 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, 524, 523, 522, 521, 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, 510, 509, 508, 507, 506, 505, 504, 503, 502, 501, 500, 499, 498, 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, 487, 486, 485, 484, 483, 482, 481, 480, 479, 478, 477, 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 457, 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, 440, 439, 438, 437, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, 407, 406, 405, 404, 403, 402, 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, 315, 314, 313, 312, 311, 310, 309, 308, 307, 306, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 262s 262s Immutable::Vector 262s #rindex 262s when passed an object present in the vector 262s returns the last index where the object is present 262s when passed an object not present in the vector 262s returns nil 262s with a block 262s returns the last index of an object which the predicate is true for 262s without an argument OR block 262s returns an Enumerator 262s 262s Immutable::Vector 262s #rotate 262s leaves the original unmodified 262s when passed no argument 262s returns a new vector with the first element moved to the end 262s with an integral argument n 262s returns a new vector with the first (n % size) elements moved to the end 262s with a floating-point argument n 262s coerces the argument to integer using to_int 262s with a non-numeric argument 262s raises a TypeError 262s with an argument of zero 262s returns self 262s with an argument equal to the vector's size 262s returns self 262s on a 31-item vector 262s behaves like Array#rotate 262s on a 32-item vector 262s behaves like Array#rotate 262s on a 33-item vector 262s behaves like Array#rotate 262s on a 1000-item vector 262s behaves like Array#rotate 262s on a 1023-item vector 262s behaves like Array#rotate 262s on a 1024-item vector 262s behaves like Array#rotate 262s on a 1025-item vector 262s behaves like Array#rotate 262s from a subclass 262s returns an instance of the subclass 262s 262s Immutable::Vector 262s #sample 262s returns a randomly chosen item 262s 262s Immutable::Vector 262s #select 262s works with a variety of inputs 262s with a block 262s preserves the original 262s returns a vector with the matching values 262s with no block 262s returns an Enumerator 262s when nothing matches 262s preserves the original 262s returns an empty vector 262s on an empty vector 262s returns self 262s from a subclass 262s returns an instance of the subclass 262s #find_all 262s works with a variety of inputs 262s with a block 262s preserves the original 262s returns a vector with the matching values 262s with no block 262s returns an Enumerator 262s when nothing matches 262s preserves the original 262s returns an empty vector 262s on an empty vector 262s returns self 262s from a subclass 262s returns an instance of the subclass 262s 262s Immutable::Vector 262s #set 262s when empty 262s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.hzIEyN/build.z6h/src/spec/lib/immutable/vector/set_spec.rb:11:in `block (4 levels) in '. 262s raises an error for index -1 262s allows indexes 0 and 1 to be set 262s when not empty 262s with a block 262s and a positive index 262s within the absolute bounds of the vector 262s passes the current value to the block 262s replaces the value with the result of the block 262s supports to_proc methods 262s just past the end of the vector 262s passes nil to the block and adds a new value 262s further outside the bounds of the vector 262s passes nil to the block, fills up missing nils, and adds a new value 262s and a negative index 262s within the absolute bounds of the vector 262s passes the current value to the block 262s replaces the value with the result of the block 262s supports to_proc methods 262s outside the absolute bounds of the vector 262s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.hzIEyN/build.z6h/src/spec/lib/immutable/vector/set_spec.rb:75:in `block (7 levels) in '. 262s raises an error 262s with a value 262s and a positive index 262s within the absolute bounds of the vector 262s preserves the original 262s sets the new value at the specified index 262s just past the end of the vector 262s adds a new value 262s outside the absolute bounds of the vector 262s fills up with nils 262s with a negative index 262s preserves the original 262s sets the new value at the specified index 262s outside the absolute bounds of the vector 262s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.hzIEyN/build.z6h/src/spec/lib/immutable/vector/set_spec.rb:125:in `block (6 levels) in '. 262s raises an error 262s from a subclass 262s returns an instance of the subclass 262s on a 10-item vector 262s works correctly 262s on a 31-item vector 262s works correctly 262s on a 32-item vector 262s works correctly 262s on a 33-item vector 262s works correctly 262s on a 1000-item vector 262s works correctly 262s on a 1023-item vector 262s works correctly 262s on a 1024-item vector 262s works correctly 262s on a 1025-item vector 262s works correctly 262s on a 2000-item vector 262s works correctly 262s with an identical value to an existing item 262s on a 1-item vector 262s returns self 262s on a 2-item vector 262s returns self 262s on a 5-item vector 262s returns self 262s on a 31-item vector 262s returns self 262s on a 32-item vector 262s returns self 262s on a 33-item vector 262s returns self 262s on a 100-item vector 262s returns self 262s on a 200-item vector 262s returns self 262s 262s Immutable::Vector 262s #shift 262s on [] 262s preserves the original 262s returns [] 262s on ["A"] 262s preserves the original 262s returns [] 262s on ["A", "B", "C"] 262s preserves the original 262s returns ["B", "C"] 262s on 1..31 262s preserves the original 262s returns 2..31 262s on 1..32 262s preserves the original 262s returns 2..32 262s on 1..33 262s preserves the original 262s returns 2..33 262s 262s Immutable::Vector 262s #shuffle 262s returns the same values, in a usually different order 262s leaves the original unchanged 262s from a subclass 262s returns an instance of the subclass 262s on a 32-item vector 262s works correctly 262s on a 33-item vector 262s works correctly 262s on a 1023-item vector 262s works correctly 262s on a 1024-item vector 262s works correctly 262s on a 1025-item vector 262s works correctly 262s 262s Immutable::Vector 262s #slice 262s when passed a positive integral index 262s returns the element at that index 262s leaves the original unchanged 262s when passed a negative integral index 262s returns the element which is number (index.abs) counting from the end of the vector 262s when passed a positive integral index and count 262s returns 'count' elements starting from 'index' 262s leaves the original unchanged 262s when passed a negative integral index and count 262s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 262s when passed a Range 262s returns the elements whose indexes are within the given Range 262s leaves the original unchanged 262s when passed a subclass of Range 262s works the same as with a Range 262s on a subclass of Vector 262s with index and count or a range, returns an instance of the subclass 262s #[] 262s when passed a positive integral index 262s returns the element at that index 262s leaves the original unchanged 262s when passed a negative integral index 262s returns the element which is number (index.abs) counting from the end of the vector 262s when passed a positive integral index and count 262s returns 'count' elements starting from 'index' 262s leaves the original unchanged 262s when passed a negative integral index and count 262s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 262s when passed a Range 262s returns the elements whose indexes are within the given Range 262s leaves the original unchanged 262s when passed a subclass of Range 262s works the same as with a Range 262s on a subclass of Vector 262s with index and count or a range, returns an instance of the subclass 262s 262s Immutable::Vector 262s #sort 262s on [] 262s with a block 262s preserves the original 262s returns [] 262s without a block 262s preserves the original 262s returns [] 262s on ["A"] 262s with a block 262s preserves the original 262s returns ["A"] 262s without a block 262s preserves the original 262s returns ["A"] 262s on ["Ichi", "Ni", "San"] 262s with a block 262s preserves the original 262s returns ["Ni", "San", "Ichi"] 262s without a block 262s preserves the original 262s returns ["Ichi", "Ni", "San"] 262s on a 10-item vector 262s behaves like Arraysort 262s on a 31-item vector 262s behaves like Arraysort 262s on a 32-item vector 262s behaves like Arraysort 262s on a 33-item vector 262s behaves like Arraysort 262s on a 1023-item vector 262s behaves like Arraysort 262s on a 1024-item vector 262s behaves like Arraysort 262s on a 1025-item vector 262s behaves like Arraysort 262s #sort_by 262s on [] 262s with a block 262s preserves the original 262s returns [] 262s without a block 262s preserves the original 262s returns [] 262s on ["A"] 262s with a block 262s preserves the original 262s returns ["A"] 262s without a block 262s preserves the original 262s returns ["A"] 262s on ["Ichi", "Ni", "San"] 262s with a block 262s preserves the original 262s returns ["Ni", "San", "Ichi"] 262s without a block 262s preserves the original 262s returns ["Ichi", "Ni", "San"] 262s on a 10-item vector 262s behaves like Arraysort_by 262s on a 31-item vector 262s behaves like Arraysort_by 262s on a 32-item vector 262s behaves like Arraysort_by 262s on a 33-item vector 262s behaves like Arraysort_by 262s on a 1023-item vector 262s behaves like Arraysort_by 262s on a 1024-item vector 262s behaves like Arraysort_by 262s on a 1025-item vector 262s behaves like Arraysort_by 262s 262s Immutable::Vector 262s #sum 262s on [] 262s returns 0 262s on [2] 262s returns 2 262s on [1, 3, 5, 7, 11] 262s returns 27 262s 262s Immutable::Vector 262s #take 262s 10 from [] 262s preserves the original 262s returns [] 262s 10 from ["A"] 262s preserves the original 262s returns ["A"] 262s 0 from ["A", "B", "C"] 262s preserves the original 262s returns [] 262s 2 from ["A", "B", "C"] 262s preserves the original 262s returns ["A", "B"] 262s 1 from 1..32 262s preserves the original 262s returns [1] 262s 32 from 1..33 262s preserves the original 262s returns 1..32 262s 40 from 1..100 262s preserves the original 262s returns 1..40 262s when number of elements specified is identical to size 262s returns self 262s when number of elements specified is bigger than size 262s returns self 262s 262s Immutable::Vector 262s #take_while 262s on [] 262s with a block 262s returns [] 262s preserves the original 262s without a block 262s returns an Enumerator 262s on ["A"] 262s with a block 262s returns ["A"] 262s preserves the original 262s without a block 262s returns an Enumerator 262s on ["A", "B", "C"] 262s with a block 262s returns ["A", "B"] 262s preserves the original 262s without a block 262s returns an Enumerator 262s 262s Immutable::Vector 262s #to_a 262s with an empty vector 262s returns the values 262s with an single item vector 262s returns the values 262s with an multi-item vector 262s returns the values 262s with a 10-item vector 262s returns the values 262s with a 31-item vector 262s returns the values 262s with a 32-item vector 262s returns the values 262s with a 33-item vector 262s returns the values 262s with a 1000-item vector 262s returns the values 262s with a 1023-item vector 262s returns the values 262s with a 1024-item vector 262s returns the values 262s with a 1025-item vector 262s returns the values 262s 262s Immutable::Vector 262s #to_ary 262s converts using block parameters 262s converts using method arguments 262s converts using splat 262s 262s Immutable::Vector 262s #to_list 262s on [] 262s returns a list 262s the returned list 262s has the correct length 262s contains all values 262s on ["A"] 262s returns a list 262s the returned list 262s has the correct length 262s contains all values 262s on ["A", "B", "C"] 262s returns a list 262s the returned list 262s has the correct length 262s contains all values 262s 262s Immutable::Vector 262s #to_set 262s on [] 262s returns a set with the same values 262s on ["A"] 262s returns a set with the same values 262s on ["A", "B", "C"] 262s returns a set with the same values 262s on 1..10 262s returns a set with the same values 262s on 1..32 262s returns a set with the same values 262s on 1..33 262s returns a set with the same values 262s on 1..1000 262s returns a set with the same values 262s 262s Immutable::Vector 262s #transpose 262s takes a vector of vectors and transposes rows and columns 262s raises an IndexError if the vectors are not of the same length 262s also works on Vectors of Arrays 262s on 10-item vectors 262s behaves like Array#transpose 262s on 31-item vectors 262s behaves like Array#transpose 262s on 32-item vectors 262s behaves like Array#transpose 262s on 33-item vectors 262s behaves like Array#transpose 262s on 1000-item vectors 262s behaves like Array#transpose 262s on 1023-item vectors 262s behaves like Array#transpose 262s on 1024-item vectors 262s behaves like Array#transpose 262s on 1025-item vectors 262s behaves like Array#transpose 262s on 2000-item vectors 262s behaves like Array#transpose 262s on a subclass of Vector 262s returns instances of the subclass 262s if an item does not respond to #size and #[] 262s raises TypeError 262s 262s Immutable::Vector 262s #uniq 262s returns a vector with no duplicates 262s leaves the original unmodified 262s uses #eql? semantics 262s also uses #hash when determining which values are duplicates 262s keeps the first of each group of duplicate values 262s when passed a block 262s uses the return value of the block to determine which items are duplicate 262s on a vector with no duplicates 262s returns an unchanged vector 262s if the vector has more than 32 elements and is initialized with Vector.new 262s returns an unchanged vector 262s on a 10-item vector 262s behaves like Array#uniq 262s on a 31-item vector 262s behaves like Array#uniq 262s on a 32-item vector 262s behaves like Array#uniq 262s on a 33-item vector 262s behaves like Array#uniq 262s on a 1000-item vector 262s behaves like Array#uniq 262s on a 1023-item vector 262s behaves like Array#uniq 262s on a 1024-item vector 262s behaves like Array#uniq 262s on a 1025-item vector 262s behaves like Array#uniq 262s on a 2000-item vector 262s behaves like Array#uniq 262s from a subclass 262s returns an instance of the subclass 262s 262s Immutable::Vector 262s #unshift 262s on [] with "A" 262s preserves the original 262s returns ["A"] 262s on ["A"] with "B" 262s preserves the original 262s returns ["B", "A"] 262s on ["A"] with "A" 262s preserves the original 262s returns ["A", "A"] 262s on ["A", "B", "C"] with "D" 262s preserves the original 262s returns ["D", "A", "B", "C"] 262s on 1..31 with 0 262s preserves the original 262s returns 0..31 262s on 1..32 with 0 262s preserves the original 262s returns 0..32 262s on 1..33 with 0 262s preserves the original 262s returns 0..33 262s 262s Immutable::Vector 262s #update_in 262s with one level on existing key 262s passes the value to the block 262s replaces the value with the result of the block 262s should preserve the original 262s with multi-level vectors on existing keys 262s passes the value to the block 262s replaces the value with the result of the block 262s should preserve the original 262s with multi-level creating sub-hashes when keys don't exist 262s passes nil to the block 262s creates subhashes on the way to set the value 262s with multi-level including hash with existing keys 262s passes the value to the block 262s replaces the value with the result of the block 262s should preserve the original 262s with empty key_path 262s raises ArguemntError 262s 262s Immutable::Vector 262s #values_at 262s accepts any number of indices, and returns a vector of items at those indices 262s when passed invalid indices 262s fills in with nils 262s when passed no arguments 262s returns an empty vector 262s from a subclass 262s returns an instance of the subclass 262s 262s Immutable::Vector 262s #zip 262s with a block 262s yields arrays of one corresponding element from each input sequence 262s fills in the missing values with nils 262s returns nil 262s can handle multiple inputs, of different classes 262s without a block 262s returns a vector of arrays (one corresponding element from each input sequence) 262s on 10-item vectors 262s behaves like Array#zip 262s on 31-item vectors 262s behaves like Array#zip 262s on 32-item vectors 262s behaves like Array#zip 262s on 33-item vectors 262s behaves like Array#zip 262s on 1000-item vectors 262s behaves like Array#zip 262s on 1023-item vectors 262s behaves like Array#zip 262s on 1024-item vectors 262s behaves like Array#zip 262s on 1025-item vectors 262s behaves like Array#zip 262s from a subclass 262s returns an instance of the subclass 262s 262s Immutable 262s Hash 262s can be loaded separately 262s Set 263s can be loaded separately 263s Vector 263s can be loaded separately 263s List 263s can be loaded separately 263s SortedSet 263s can be loaded separately 263s Deque 263s can be loaded separately 263s 263s Top 10 slowest examples (5 seconds, 31.3% of total time): 263s Immutable::List#each_chunk on a really big list doesn't run out of stack 263s 0.91488 seconds ./spec/lib/immutable/list/each_slice_spec.rb:7 263s Immutable::List#each_slice on a really big list doesn't run out of stack 263s 0.81727 seconds ./spec/lib/immutable/list/each_slice_spec.rb:7 263s Immutable::Hash#size has the correct size after lots of addings and removings 263s 0.7126 seconds ./spec/lib/immutable/hash/size_spec.rb:38 263s Immutable::List#partition calls the passed block only once for each item, even with multiple threads 263s 0.50783 seconds ./spec/lib/immutable/list/partition_spec.rb:38 263s Immutable::List#hash on a really big list doesn't run out of stack 263s 0.48333 seconds ./spec/lib/immutable/list/hash_spec.rb:6 263s Immutable::Hash#except works on a large Hash, with many combinations of input 263s 0.34976 seconds ./spec/lib/immutable/hash/except_spec.rb:29 263s Immutable::List ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads 263s 0.32019 seconds ./spec/lib/immutable/list/multithreading_spec.rb:5 263s Immutable::SortedSet#marshal_dump/#marshal_load can survive dumping and loading into a new process 263s 0.31418 seconds ./spec/lib/immutable/sorted_set/marshal_spec.rb:20 263s Immutable::Hash#length has the correct size after lots of addings and removings 263s 0.29585 seconds ./spec/lib/immutable/hash/size_spec.rb:38 263s Immutable::Deque#marshal_dump/#marshal_load is still possible to push and pop items after loading 263s 0.28766 seconds ./spec/lib/immutable/deque/marshal_spec.rb:24 263s 263s Top 10 slowest example groups: 263s Immutable::Hash 263s 0.27948 seconds average (0.55895 seconds / 2 examples) ./spec/lib/immutable/hash/marshal_spec.rb:3 263s Immutable::Deque 263s 0.279 seconds average (0.558 seconds / 2 examples) ./spec/lib/immutable/deque/marshal_spec.rb:3 263s Immutable::Vector 263s 0.26774 seconds average (0.53547 seconds / 2 examples) ./spec/lib/immutable/vector/marshal_spec.rb:3 263s Immutable::Set 263s 0.2591 seconds average (0.51821 seconds / 2 examples) ./spec/lib/immutable/set/marshal_spec.rb:3 263s Immutable::SortedSet 263s 0.19564 seconds average (0.58693 seconds / 3 examples) ./spec/lib/immutable/sorted_set/marshal_spec.rb:3 263s Immutable 263s 0.18779 seconds average (1.13 seconds / 6 examples) ./spec/lib/load_spec.rb:6 263s Immutable::List 263s 0.16646 seconds average (0.49937 seconds / 3 examples) ./spec/lib/immutable/list/hash_spec.rb:3 263s Immutable::List 263s 0.14963 seconds average (0.44888 seconds / 3 examples) ./spec/lib/immutable/list/multithreading_spec.rb:4 263s Immutable::Hash 263s 0.12711 seconds average (1.27 seconds / 10 examples) ./spec/lib/immutable/hash/size_spec.rb:3 263s Immutable::Hash 263s 0.07036 seconds average (0.35178 seconds / 5 examples) ./spec/lib/immutable/hash/except_spec.rb:3 263s 263s Finished in 15.98 seconds (files took 2.26 seconds to load) 263s 4608 examples, 0 failures 263s 263s mv ./.gem2deb.lib lib 264s autopkgtest [07:08:58]: test gem2deb-test-runner: -----------------------] 268s gem2deb-test-runner PASS 268s autopkgtest [07:09:02]: test gem2deb-test-runner: - - - - - - - - - - results - - - - - - - - - - 272s autopkgtest [07:09:06]: @@@@@@@@@@@@@@@@@@@@ summary 272s gem2deb-test-runner PASS