<h2>C#</h2>
<pre class="hl csharp">
<code>
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

using Spreads.Collections.Concurrent;
using System;
using System.Data;
using Spreads.SQLite.Utilities;
using static Spreads.SQLite.Interop.NativeMethods.Sqlite3_spreads_sqlite3;

namespace Spreads.SQLite.Fast
{
    public class ConnectionPool : IDisposable
    {
        private ConnectionState _state;
        private readonly LockedObjectPool<SqliteConnection> _pool;

        public ConnectionPool(string connectionString)
        {
            ConnectionString = connectionString;
            _pool = new LockedObjectPool<SqliteConnection>(Environment.ProcessorCount * 2, OpenConnection);
            // construct first object for exception on construction if any
            _pool.Return(_pool.Rent());
            _state = ConnectionState.Open;
        }

        public string ConnectionString { get; }

        private SqliteConnection OpenConnection()
        {
            var connection = new SqliteConnection(ConnectionString);
            connection.Open();
            sqlite3_extended_result_codes(connection.DbHandle, 1);
            InitConnection(connection);
            return connection;
        }

        public virtual void InitConnection(SqliteConnection connection)
        {
            connection.ExecuteNonQuery("PRAGMA main.page_size = 4096; ");
            connection.ExecuteNonQuery("PRAGMA main.cache_size = 25000;");
            connection.ExecuteNonQuery("PRAGMA synchronous = NORMAL;");
            connection.ExecuteNonQuery("PRAGMA journal_mode = WAL;");
        }

        public void Release(SqliteConnection handle)
        {
            lock (_pool)
            {
                if (_state == ConnectionState.Closed)
                {
                    ThrowHelper.ThrowInvalidOperationException("_state == ConnectionState.Closed");
                }

                var pooled = _pool.Return(handle);
                if (!pooled)
                {
                    handle.Dispose();
                }
            }
        }

        public SqliteConnection Rent()
        {
            lock (_pool)
            {
                if (_state == ConnectionState.Closed)
                {
                    ThrowHelper.ThrowInvalidOperationException("_state == ConnectionState.Closed");
                }
                return _pool.Rent();
            }
        }

        public void Dispose()
        {
            lock (_pool)
            {
                _pool.Dispose();
                _state = ConnectionState.Closed;
            }
        }
    }
}
</code>
</pre>

<h2>Javascript</h2>
<pre class="hl js"><code>
/**
 * Iterates over properties of `object`, returning an array of all elements
 * `predicate` returns truthy for. The predicate is invoked with three
 * arguments: (value, key, object).
 *
 * If you want an object in return, consider `pickBy`.
 *
 * @since 5.0.0
 * @category Object
 * @param {Object} object The object to iterate over.
 * @param {Function} predicate The function invoked per iteration.
 * @returns {Array} Returns the new filtered array.
 * @see pickBy, pull, pullAll, pullAllBy, pullAllWith, pullAt, remove, reject
 * @example
 *
 * const object = { 'a': 5, 'b': 8, 'c': 10 }
 *
 * filterObject(object, (n) => !(n % 5))
 * // => [5, 10]
 */
function filterObject(object, predicate) {
  object = Object(object)
  const result = []

  Object.keys(object).forEach((key) => {
    const value = object[key]
    if (predicate(value, key, object)) {
      result.push(value)
    }
  })
  return result
}

export default 
</code></pre>\

<h2>Ruby</h2>
<pre class="hl ruby">
<code>
# frozen_string_literal: true

require "abstract_controller/collector"
require "active_support/core_ext/hash/reverse_merge"
require "active_support/core_ext/array/extract_options"

module ActionMailer
  class Collector
    include AbstractController::Collector
    attr_reader :responses

    def initialize(context, &block)
      @context = context
      @responses = []
      @default_render = block
    end

    def any(*args, &block)
      options = args.extract_options!
      raise ArgumentError, "You have to supply at least one format" if args.empty?
      args.each { |type| send(type, options.dup, &block) }
    end
    alias :all :any

    def custom(mime, options = {})
      options.reverse_merge!(content_type: mime.to_s)
      @context.formats = [mime.to_sym]
      options[:body] = block_given? ? yield : @default_render.call
      @responses << options
    end
  end
end
</code>
</pre>

<h2>Rust</h2>
<pre class="hl rust"><code>
// This powerful wrapper provides the ability to store a positive integer value.
// Rewrite it using generics so that it supports wrapping ANY type.

// I AM NOT DONE
struct Wrapper<u32> {
    value: u32
}

impl<u32> Wrapper<u32> {
    pub fn new(value: u32) -> Self {
        Wrapper { value }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn store_u32_in_wrapper() {
        assert_eq!(Wrapper::new(42).value,  42);
    }

    #[test]
    fn store_str_in_wrapper() {
        // TODO: Delete this assert and uncomment the one  below once you have  finished the exercise.
        assert!(false);
        // assert_eq!(Wrapper::new("Foo").value, "Foo");
    }
}
</code></pre>