lang:      language object represents your language.
489508
def build_language(source_code: str, lang: Language, filename: str):
    
    state = MetaState(rbnf.implementation, requires=_Wild(), filename=filename)
    state.data = lang
    _build_language(source_code, state)
    lang.build()
1147942
def classify_languages(self):
        
        return BlobsWithLanguageDataFrame(self._engine_dataframe.classifyLanguages(),
                                          self._session, self._implicits)
526160
function scan(language) {
            var i;
            for (i = 0; i < availableLanguages.length; i += 1) {
                if (language.toLowerCase() === availableLanguages[i].toLowerCase()) {
                    return availableLanguages[i];
                }
            }
        }
1345273
def language(lang)
      lang ||= :none
      @_stemmer = XapianDb::Repositories::Stemmer.stemmer_for lang
      @_stopper = lang == :none ? nil : XapianDb::Repositories::Stopper.stopper_for(lang)
    end
1147387
def translation(language):
    
    global _translations
    if language not in _translations:
        _translations[language] = Translations(language)
    return _translations[language]
900201
function makeLanguageObj(langStr) {
        var shortName;
        shortName = langStr.toLowerCase().substr(0,2);
        return {
            name: langStr,
            shortName: shortName,
            nativeName: langStr,
            path: shortName + '/'
        };
    }
1222448
def supported_language(lang):
    
    try:
      self.get_collection(lang=lang)
      return True
    except LanguageNotSupported as e:
      return False
999616
function language(opt) {

  var options = opt || Object.create(null);
  var include = __dirname + '/min/lib/dictionary.js';
  var lang = options.dictionary || require(include).LANG;
  var my = {
    cookie: String(options.cookie || 'lang'),
    domain: String(options.domain || ''),
    path: String(options.path || '/'),
    maxAge: Number(options.maxAge) || 1000 * 3600 * 24 * 365,
    httpOnly: Boolean(options.httpOnly),
    secure: Boolean(options.secure),
    signed: Boolean(options.signed)
  };

  if (lang._default === undefined) {
    lang = require(include).LANG;
  } else if (!all[lang._default]) {
    console.error('language misconfigured');
    lang = require(include).LANG;
  }
  /**
   * @global
   */
  process.env.lang = lang._default;
  // return
  var cookie = 'cookies';
  if (my.signed) {
    cookie = 'signedCookies';
  }

  if (typeof options.encryptionSecret === 'string') {
    var vault = require('cookie-encryption');
    var encryptionOptions = opt.encryptionOptions || Object.create(null);
    vault = vault(options.encryptionSecret, {
      cookie: my.cookie,
      cipher: encryptionOptions.cipher,
      encoding: encryptionOptions.encoding,
      extra: encryptionOptions.extra,
      domain: encryptionOptions.domain || my.domain,
      path: encryptionOptions.path || my.path,
      maxAge: encryptionOptions.maxAge || my.maxAge,
      httpOnly: encryptionOptions.httpOnly || my.httpOnly,
      secure: encryptionOptions.secure || my.secure,
      signed: encryptionOptions.signed || my.signed
    });

    /**
     * detect language and (if accepted) build it. Store information on cookie
     * 
     * @function browser
     * @param {Object} req - client request
     * @param {Object} res - response to client
     * @param {next} next - continue routes
     */
    return function browser(req, res, next) {

      var biscotto;
      try {
        biscotto = vault.read(req);
      } catch (e) { // fails to decrpy
        biscotto = undefined;
      }
      if (biscotto && lang[biscotto]) { // lookup
        req[cookie][my.cookie] = biscotto;
        return next();
      }

      var ll = detect(lang._default, req.headers['accept-language'], lang);
      req[cookie][my.cookie] = vault.write(req, ll); // populate req[cookie] by module

      return next();
    };
  }

  /**
   * detect language and (if accepted) build it. Store information on cookie
   * 
   * @function browser
   * @param {Object} req - client request
   * @param {Object} res - response to client
   * @param {next} next - continue routes
   */
  return function browser(req, res, next) {

    var biscotto = req[cookie];
    if (biscotto === undefined) {
      biscotto = Object.create(null);
    } else if (lang[biscotto[my.cookie]]) { // lookup
      return next();
    }

    var ll = detect(lang._default, req.headers['accept-language'], lang);
    biscotto[my.cookie] = set(my, res, ll);

    return next();
  };
}
839234
def set_language(self, language):
        
        if isinstance(language, str):
            language_obj = languages.getlang(language)
            if language_obj:
                self.language = language_obj.code
            else:
                raise TypeError("Language code {} not found".format(language))
        if isinstance(language, languages.Language):
            self.language = language.code
778181
private static Language parseNextLanguage(Element element) {
        Language language = new Language();

        language.setName(DOMHelper.getValueFromElement(element, "name"));
        language.setAbbreviation(DOMHelper.getValueFromElement(element, "abbreviation"));
        language.setId(DOMHelper.getValueFromElement(element, "id"));

        return language;
    }
1071634
def lang(self):
        
        return str(self.graph.value(self.asNode(), DC.language))
771860
private long insertNewLanguage(final String _language)
    {
        Long ret = null;
        try {
            final Insert insert = new Insert(CIAdmin.Language);
            insert.add(CIAdmin.Language.Language, _language);
            insert.executeWithoutAccessCheck();
            ret = insert.getId();
            insert.close();
        } catch (final EFapsException e) {
            DBPropertiesUpdate.LOG.error("insertNewLanguage()", e);
        }
        return ret;
    }
1329915
public static void setLanguage(LanguageSelect lang) {
		if (lang == null) GuildWars2.lang = LanguageSelect.English;
		else GuildWars2.lang = lang;
	}
755477
function(english, language) {
    if (typeof translations[english] !== 'undefined' && typeof translations[english][language] !== 'undefined') {
      return translations[english][language];
    } else {
      return english;
    }
  }
1008329
def language=(language)
      validator = EnumAttributeValidator.new('String', ["afts", "lucene", "cmis"])
      unless validator.valid?(language)
        fail ArgumentError, "invalid value for 'language', must be one of #{validator.allowable_values}."
      end
      @language = language
    end
80891
function parser(lang, opts) {
  lang = lang || opts.lang;
  if (engines.hasOwnProperty(lang)) {
    return engines[lang];
  }
  return engines.yaml;
}
936655
function resolveLanguage ( value ) {
	if ( typeof value === 'string' ) {
		const lang = _.find(langs, ( o ) => { return o.locale.indexOf(value) !== -1; });
		if ( typeof lang !== 'undefined' ) {
			return lang.id;
		}
	}
	return value;
}