Happy New Year everyone! I hope 2018 brings peace, prosperity, good health, and for those who are looking, a new career.
The New Year is a time for reflection and often with that reflection, a strong desire for personal growth and change. While personal growth and change are challenging, we realize that we need to make these changes in order to be a better person and to better adapt to our new surroundings. As the famous country music singer Jimmy Buffet said, "Changes in latitudes, changes in attitudes, nothing remains quite the same." The same is true with our approach to being in a new country, adapting to a new culture, and finding new work.
If I had to give any newcomer advice on their job search, I would say make sure you learn to adapt to your new surroundings. Living in Canada is not easy; the transition to a different culture, climate, language and professional expectations is extremely challenging. You have so many hurdles to jump and barriers to conquer. Navigating these strange cultural waters while trying to prepare your children for school and getting ready for work is really a test of your inner strength. Having said that, living in Canada is incredibly rewarding; there is diversity, understanding, laws that benefit all, freedom and peace. It is a beautiful country populated by people from all over the world, however, you have to learn to adapt and you have to want to embrace the changes in order to reap the benefits. If you do, I promise, your life will be successful in your new country.
The wonderful thing about Canada is that there are many resources in place to help newly-arrived immigrants. Many years ago, when my family was settling from Eastern Europe, the city of Toronto had few things in place to assist newcomers. Those early settling immigrants forged ahead embracing all their new country and city had to offer despite a lack of assistance. These people established businesses, they worked at low-paying jobs, they bought homes, they started communities with places of worship, and they raised families. The city of Toronto is peppered by many wonderful communities which is a strong indication of the settlement process: Little Italy, Greektown, Little India, Chinatown, Koreatown, Portugal Village, Little Poland, and Little Malta are just a few of the communities that makes Toronto so unique. In many cases, these neighbourhoods and communities were established with little or no assistance from governmentally-sponsored settlement agencies.
Today, it is an entirely different story. There are so many places that can offer newcomers assistance! Look into organizations that are geared towards specifically settling immigrants for assistance. Try to remember that you are not alone! These organizations have language classes, groups for seniors and youth, settlement adaptation programs, business start-up courses, translation and legal services. For the most part, for those who qualify, the services are all free.
There are organizations that assist you with your credential evaluation. World Education Services, ICAS, and the University of Toronto's Comparative Education Services will work with you to make sure your documents are at the level they need to be to find work or pursue education.
Use the National Occupation Classification system to research what employers want. Research the Conference Board of Canada for information about job search. Find out through country-wide surveys, what Canadian employers want most from their employees.
There are bridging programs that are designed to ease the transition back to education for Internationally Trained Professionals (ITPs) into the workplace. Check out any university or community college for more information.
For those ITPs who have a very high level of English language skills, look for Enhanced Language Training (ELT) courses. These courses are offered at several settlement agencies throughout the GTA and usually attach an unpaid internship at a reputable organization within your professional field of interest. In most cases, those internships lead to full-time paid employment.
On a personal level, learn what makes Canadians tick! Google Canadian Idioms and start incorporating this crazy "new" language into your lexicon because the last thing you want is to be on the "outside looking in" for the rest of your life. Adapting and adopting these language changes brings you closer to your goal of fitting in.
Find out what Canadians are talking about. This is as easy as reading online web-papers from the CBC (www.cbc.ca) and Toronto Star (www.thestar.com). There are articles about current events on every single imaginable topic and the nicest thing…they're free!
Find out how to look for work and learn how to interview. You will see that it's very different from your previous country. Learn how to tell stories to answer behavioural questions.
Try a physical makeover! There are organizations such as Dress for Success and Dress Your Best that provide appropriate women's and men's business clothing at very low prices.
In the future, this section of The Migrant will focus on job search and interviewing tips, the importance of all forms of communication and everything you need to help you adapt, adopt and embrace your new country. I look forward to working with you!
Vicki has spent the past 20 years coaching and working with internationally trained professionals and helping them transition their skills into the Canadian workforce. She has created and taught curriculum that includes relevant skills training for newcomers. She currently teaches the Labour Market Access for Newcomers to Canada program at the Newcomer Centre of Peel in addition to the Workplace Communication in Canada program at Ryerson University. She holds a Bachelor of Arts in English, a Bachelor of Education, and a Master's degree in Applied Linguistics and is TESL certified.


SMILEY N. POOL: CHRONICLE HOLD ON THERE: Cy-Fair quarterback Logan Taylor (6) slips out of the grasp of Hightower linebacker Nick Rodriguez (33) during Saturday's Class 5A playoff game at Tully Stadium.
After some late-game heroics from Hightower quarterback Bralon Addison, the Hurricanes advanced to the Class 5A Division I Region III title game next week with a 21-14 win over Cy-Fair at Tully Stadium on Saturday.
Late in the game with a one-touchdown lead, the Hurricanes were faced with a 4th-and-3 on their own 21 with just under three minutes to play.
Hightower set up for Addison's quick-kick, but the senior, who is committed to Texas A&M, decided to run for it. He ran for 14 yards, the first down and nailed down the win for Hightower (11-2).
"That's what you do - you put your best players in positions to win games and Bralon is my best player," Hightower coach Barry Abercrombie said. "I trust him to make the right decisions out there."
The Hurricanes will face defending state champion Pearland (11-2), 1 p.m. Saturday, at Tully for a spot in the state semifinals.
Westfield 33, Rowlett 25 - In Georgetown, Kreigan Bridges and Kaylon Jackson ran for fourth-quarter touchdowns as Westfield rallied to beat Rowlett in a Class 5A Division II Region II semifinal in which winds were gusting in excess of 40 mph.
Westfield (10-3) advanced to play Dekaney, while Rowlett finished the season 8-5.
Jackson finished with 35 carries for 167 yards for Westfield.
Dallas Skyline 42, Klein Oak 24 - In Waco, Skyline took advantage of a pair of key defensive stops to break open a close game against Klein Oak in the second half.
The Raiders scored three times in the third quarter to extend a 14-10 halftime lead to 35-16.
Skyline's defense stopped Klein Oak twice inside the 20 and turned both into scoring drives of 88 and 81 yards.
Klein Oak quarterback Connor McQueen threw for 252 yards and three touchdowns, but couldn't match the big plays that Skyline got in the second half.
Dawson 33, Nederland 25 - Nederland surprised Dawson with its explosiveness in the first half at Galena Park ISD Stadium.
Once the surprise wore off, the Bulldogs wore down under the constant onslaught of the Eagles' offense.
Dawson, trailing 18-14 at the half, scored touchdowns on all three of its third-quarter possessions to take control of an eventual 33-25 victory in the Class 4A Division 1 Region III semifinals.
The Eagles (11-2), despite stumbling in their final two regular-season games, are heading back to the regionals finals for the second time in three years.
They'll face Angleton at The Rig next week.


Landscaping Estimate Template – Trying to find an ideal budgeting worksheet could be like trying to find the right used car: there's a million offered but choosing the best one can frustrating. Searching the internet provides an unlimited way to obtain worksheets available with numerous levels of price and quality. As you go through all the options available, keep these tips at heart to get the one that's correct for you.
Now, mainly because a former instructor I am not saying that one should never use math worksheets; however, I really do think that many teachers are using a very superficial approach to instruction that relies too much on low-level mathematics worksheets and hands-off instructional techniques. Worksheet lessons move from reading the directions aloud, to doing sample problems as a mixed group, to completing the worksheet independently (or at home with parents), day in and full day out.
Math worksheets are not engaging. Numerous research studies have discovered that when college students are actively engaged with the content, they have a much better chance of understanding and remembering what they have learned. Unfortunately, math worksheets have a tendency to bore most students, those that need the most help in math especially.
A fully functional budgeting worksheet should calculate your monthly cash flow analysis so that you can determine if you're overspending based about your income on a monthly basis. To be able to determine your cash flow for the full month, you shall have to provide your monthly income information. A good worksheet must do all the mathematics for you, generate a meaningful chart or two so that you can quickly start to see the areas in your budget that need to be improved upon. In case you are over spending, you shall have to adjust. In case you are under spending, start conserving towards your goals!
By integrating just about any expense to your monthly budget, then you may rest assured that your entire obligations will probably be taken good care of. Look online for cases of the budgeting worksheet you could use to begin. Many of these are free and also you also may probably find that they create the job of creating a price range much easier.
Related Posts of "Landscaping Estimate Template"


It was interesting to see this only a couple of days after Rosencrantz & Guildenstern Are Dead. The set had two ramps slanting across the stage at right angles, with stool-steps behind, for easy access as well as seating. The back of the forward ramp, which ran right to left, had an inbuilt piano, which was used to good effect, while the ramp on the left, which ran roughly back to front, included a nifty two-door grave, reminiscent of an Andersen shelter (more on that story later). Around the back were some strange wire thingies – several pairs of wires stretched floor to flies, with a large trapezium of white material between them at about the level of the balcony. A strip of dark gray Lurex was wrapped around the base of these wires, with some grouped together and some pairs done individually. Only the central group was different – the fabric was plain black, and for the second half it was pulled up to form the arras behind which Polonius hid; the rest of the strips only came up two or three feet. There were a couple of chairs for Claudius and Gertrude during the play scene, and various other implements were brought on as needed, but that was pretty much it.
I have no idea what the wire and cloth arrangements were meant to be, but at the start, we soon realised we were in the Second World War period. It started with a public service announcement about switching off all phones, done in the plummy tones and formal language of such things, and then the opening scene was preceded by an air raid siren; this made me think that the wire sculptures might represent search lights, but apart from that fleeting thought, nothing much came of them. There was also a piper at the start – fine playing, but no idea why.
The first scene was done in near darkness, with torches, and Francisco was standing right beside me for his few lines. The strong northern accents were well to the fore from the off, although Rosencrantz and Guildenstern were Scottish, and Hamlet had spent so long in Wittenberg that he often lapsed into RP with odd flashes of 'up north'. For once, it's Horatio who asks what all the warlike preparations are for, and Marcellus or Bernardo who tells him – this makes much more sense than the usual format. The ghost appears on the balcony, wearing a fetching white cape and a fencing mask, while waving his sword around in slow motion. Although it gives the lie to the later reports to Hamlet about the ghost's expression, etc., this staging did have the advantage of allowing them to show the ghost flitting around a lot with the use of some poles and duplicate capes and masks – the ghost appeared on either side of the stage before disappearing altogether.
The next scene began with a lively jazz number, which perked things up no end. Actually, it started with one man coming on, hat pulled down, with his jacket slung over his shoulder. He walked slowly to the end of the ramp on the right, lifted the piano lid, sat down, and played a chord. Slowly, deliberately, repeating it once. I thought, oh, it's the death march, and then he picked up the beat, the tune began to swing, and as the lights came up the rest of the band came on stage to treat us to a great little jazz number. Ophelia, in a gorgeous evening dress with more swags than a Palladium curtain, stood at a microphone on the ramp in front of the pianist, and sang the songs from her mad scene – 'valentine' and 'how should I your true love know' – all nice and lovely in this context. Gertrude arrives on the other ramp, and sashays about a bit, to applause from the court. Turns out Claudius was the piano player. Hamlet played double bass, Polonius the cello, and the rest all seem to be playing anything and everything from time to time. Talented bunch. This upbeat start to the scene makes Claudius's speech much lighter in tone, and he comes across as a pretty good guy. Cornelius has become Cornelia again, while Fortinbras is referred to as 'she' – I wasn't sure I'd heard it right first time round, but we even get to see and hear her in this production, so there's no mistake.
All this while, after the music stopped, Hamlet has been sulking over near us, sitting on the corner of the ramp. When he gets involved, he simply stands up to say his lines, putting some heat into the "Tis not my inky cloak" bit, but otherwise seeming a bit static. Left to himself for the "too, too solid flesh" speech, he does start to move around, dropping to his knees and other signs of suffering. The dialogue came across well enough, though.
The scene with Horatio was fine, as was Laertes's leave-taking. Ophelia can be quite snappy in this production, and it comes out here as well as in the mad scene. Polonius needed to refer to a little notebook for some of his precepts, a reflection on the character rather than the actor, but judging by Laertes's reaction to the contents of the envelope Polonius gives him, he's a generous man to his children.
The platform scenes had some problems, mostly in the second phase, when Hamlet talks with his father's ghost. The ghost appeared on the balcony at first, and disappeared quite quickly, but came through the rear entrance onto the ramp almost before Horatio and Marcellus had finished making their exits that way. Whenever the ghost was on stage, they played church-type music in the background – organ playing, choir singing – but this time it was loud enough to drown out a lot of Hamlet's lines. Of course, it didn't help that his back was turned to us for most of this scene, but one way and another I hardly heard a word he said. The ghost was loud and clear, and mercifully short compared to usual. Hamlet is much different after this encounter – much more lively and energetic. He also has his father's sword, which the ghost gives him – strange ghost, this – which is handy for the swearing scene. He also scrawls something in chalk on the right-hand ramp which I couldn't see, but it related to "meet it is I set it down", so I assume the word 'villain' was in there at least. Nobody else seems to see this, or the other stuff he writes later, and I wasn't taken with it as a staging choice.
Polonius sends Reynaldo off to France with the usual instructions, although he doesn't mention drabbing as a potential slur on Laertes's character, whether from brevity or morality I couldn't tell. Ophelia's report on Hamlet's mad appearance was OK, and it started to bring out the lack of physical contact between father and daughter, unlike her fond embraces with Laertes earlier on. Polonius was more disturbed by the error he's made in cutting Hamlet off from Ophelia than I've seen before, and his concern seemed genuine.
Now for Rosencrantz and Guildenstern, and if you couldn't tell them apart before, you wouldn't have had a hope this time around. Apart from their suits – one a light tan, the other grey – they were identical. Twins or brothers, I'm not sure, but since I focused on their outfits I was fine. Claudius gets it wrong (again!), then we hear from the ambassadors, and finally Polonius struts his stuff with Hamlet's letter to Ophelia.
For Hamlet's next entrance, he's carrying a fishing basket, rod and stool, and wearing a waterproof and hat. He dumps this stuff at the bottom of the ramp, and he's busy getting things out of the basket while talking to Polonius. The fishmonger reference is therefore apt, though I felt it was a bit contrived. Still, it was fun. He also has a book, which is used for the "Words, words, words" bit, and he chalks "gone fishing" on a small blackboard and props it on a stool, which got a laugh.
Rosencrantz and Guildenstern have the usual tough time of it, and then Polonius introduces the players. They're very jolly. One chap in particular is keen to give a speech himself, but it turns out Hamlet wants one that's not his to give – I thought he looked a bit disappointed. Hamlet's intro was significantly helped by a prompt from the lady player, and the rest of the speech was very well delivered. I was aware of Hecuba snatching up the blanket to cover her naked body, and I had an unexpected glimpse of a physical aspect to her relationship with Priam. The player wasn't at all bothered about Hamlet's request for The Murder of Gonzago, so the general public obviously aren't suspicious of the succession.
I wasn't sure when the interval would be taken – not at "the play's the thing" this time – so we continued with Rosencrantz and Guildenstern reporting to the king and queen on their lack of progress. Then there's the setting up of the confrontation between Ophelia and Hamlet, and then the big one – "To be, or not to be". OK, everyone wants to find their own way of doing it, but this choice just wasn't that good. Hamlet uses the chalk again, and scrawls the question on the top of the left-hand ramp. I could see the writing this time, but that really didn't improve things. He treated the first part of the speech like a pros and cons list, writing under "not to be" such things as "die", "sleep", "dream"; all this writing was done with his back to us and it felt more like an old-fashioned classroom talk than a vibrant dynamic speech about Hamlet's internal philosophical wrestling. He recovered a bit with the latter part of the speech, but on the whole this was not a good version of this important section of the play.
The meeting with Ophelia was much better, with Ophelia being a little snappy again when she tells him "Rich gifts wax poor when givers prove unkind". She's also very upset at Hamlet's ranting, sobbing and distraught and in need of a hug when her father and Claudius re-emerge. Polonius isn't keen, and avoids her altogether. I wasn't sure if Hamlet was aware of Polonius's presence after "Where's your father?" – it just wasn't clear.
The advice to the players was fine, and with Claudius and Gertrude sitting on the left-hand ramp, the play got underway. The opening mime sequence was a very fresh take to my eyes. Two players brought on a wheelbarrow, placing it well up on the right-hand ramp, and they were wearing smocks. With some music and 'effects' – they used a watering can, I think – first one row of flowers stood up in the barrow, then the next, and finally the man sorts of leans down and rests his head on the flowers to have a kip. The woman leaves, and another chap comes on with the poison, and actually invites Claudius to come on stage and pour it into the sleeping man's ear! It was all very jokey, and I could see why Claudius wouldn't be too worried by it. In fact, it was entertaining enough that I wasn't watching the court's reactions at all. When the dumb show king dies, he literally kicked the bucket. Yes, literally! There was a bucket on the ramp, he stood up, staggered about a bit, then stopped to deliberately kick the bucket off the ramp, and then collapsed and died. It was very good fun.
For the second part, the players did a lovely version of Brief Encounter. The loving couple were Celia Johnson and Trevor Howard to a T, including the little fur stole she wore and the clipped accents, which sounded strange with Shakespeare's dialogue, but the reference was worth it. When the poisoning happened, Claudius reacted strongly and stalked off, calling for a light. The rest of the scene was pretty standard, and then the interval.
The second half started with the short scene between Claudius and first Rosencrantz and Guildenstern, and then Polonius, followed by the attempted reconciliation with heaven. Fine Time Fontayne, as Claudius, gave one of the best performances today, and this speech was particularly well done, leaving him sitting on the front ramp in the appearance of prayer when Hamlet arrives on the scene. Standing close behind Claudius, he's ready to strike, but has second thoughts. It's one of those odd things; why should he think that Claudius would go to heaven when he's committed murder? And a brother's murder at that? The belief that forgiveness is always available for repentance must have been very strong for the doubts to stand any sort of chance in Hamlet's mind. Anyway, we want the rest of the play, so fortunately Hamlet decides against taking this perfect opportunity, and heads off to his mother's room. Claudius is then free to tell us how ineffective his efforts have been, and also leaves the stage.
Hamlet is soon with his mother in her chamber, with Polonius ensconced behind the arras, partially visible to us. This scene seemed a bit flat to me, although the dialogue came across well enough. Gertrude was certainly upset by the whole thing, but I didn't get any sense that she realised that Claudius was a murderer. And she must have had excellent eyesight, because the two pictures Hamlet was holding up for comparison were rather small, and he was standing several metres away from her during that bit, though of course, she would be able to remember what each man looked like. The ghost was fine, but for once I wondered if it would be possible to drop the physical presence and just hear the ghost's words, so that the audience could relate more to Gertrude's point of view, assuming the production has decided that she doesn't see the ghost, of course. For once, Hamlet doesn't bid his mother not to do the things he tells her to do, but he does drag Polonius's body away, thankfully.
Despatching Hamlet to England doesn't take long, and then we meet Fortinbras and her army, followed quickly by Ophelia's first mad scene. This wasn't too bad, with Ophelia throwing papers around and singing snatches of the songs she sang at the start of the play. There's more menace in her threat that "my brother shall know of it" than usual. Then Laertes arrives, and when Ophelia returns she has a small bunch of flowers in her hand to distribute. She's already thrown the papers about, and also drops a lot of the flowers, so the stage is beginning to look rather untidy, and gets more cluttered as the play continues.
Horatio reads the letter from Hamlet standing in the balcony, and then Claudius and Laertes seal their pact to kill Hamlet down below. Gertrude reports Ophelia's death, and then the gravedigger comes on to prepare for Ophelia's funeral. He opens up the doors to the Andersen shelter, and starts pulling skulls out of it (why are there never any other bones?), leaving one of them perched on his spade, leaning against the wall. Hamlet and Horatio walk on behind him, and as they talk, the gravedigger tosses fresh skulls over his head which they catch. The skull on the spade is Yorick's.
The funeral is very brief, just a quick up, down and across, and the priest is done. Hamlet and Horatio are crouched by the end of the right-hand ramp, and Hamlet is pretty vigorous in attacking Laertes over who loved Ophelia the most.
Now we're into the final phase, and Hamlet recounts his adventures at sea to Horatio. The sequence with Osric was good, with Osric's hat being bent out of shape so that he looked ridiculous when he put it back on. Osric and Reynaldo were one and the same, by the way – Andy Cryer did very well with this part. Osric's fussiness was clear, and he obviously had a prepared speech – he checked his clipboard from time to time – and was easily flustered by Hamlet's responses.
The fight scene worked fine. The poisoned cup was set on a stand to the left, the combatants had fencing gear on, and the fighting itself was reasonably good. Hamlet is standing with his back to Laertes, who's on the ground, when Laertes cuts him on the back of the leg, and then Hamlet's furious and unstoppable in his determination to get back at Laertes. Even without a sword, he overcomes Laertes and cuts him in return. The queen has already drunk the poison, and it's all going horribly wrong from Claudius's point of view. It gets worse. Hamlet stabs him, pours some drink down his throat, then carries the cup over to Laertes to exchange forgiveness with him; Laertes dies before Hamlet can complete his side of the bargain.
After that, it's a quick trot to the end of the play, with Fortinbras turning up and making her claim to the throne. All jolly good fun, and despite some dubious choices in the staging, and a dreadfully sparse audience, we gave them a warm reception at the end. I felt the Second World War theme was underused, and the performances were sometimes patchy, but on the whole it was the usual sound, well-spoken no-nonsense Northern Broadsides production. The music was lovely, and well-chosen, although I've already made it clear that the ghost's accompaniment was a bit too much.
This was a reasonably decent modern supernatural thriller, which didn't scare me much, but did have some tension, and the unravelling of the story was well done. It was a two-hander with a cast instantly recognisable from the soaps – Cathy Shipton as Amanda Schilling and Brian Capron as Edgar Ryme, a supposed clairvoyant. She's a journalist who claims to be doing an article on clairvoyants, and is willing to pay him for his time and information. They swap ghost stories and it's clear she's got something to hide, but then so does he, and then strange things begin to happen…….
The set was a small living/dining room in an upstairs flat. Window with permanently drawn curtains to the left, then the door to the kitchen, then an area I couldn't see very well – hidden by the table – but it had the record player, then the dresser with various windmills and other knick-knacks. Centre back was the fireplace with a large mirror over; the fireplace was screened off with a board and there was a small electric fire in front of that. The door to the outside world was to the right of the fireplace, then a table and comfy chair. There was a sofa under the window, and the dining table with chairs was front and left.
We moved closer in the interval, as I wasn't able to hear all the dialogue in our original seats. Sadly, the theatre was less than half-full, so we had no problem relocating. The title refers to the poem Antigonish by Hughes Mearns (I'm relying on Wikipedia here, so fingers crossed), which David keeps reciting as part of his strategy for taking over Edgar, and it did become a bit creepy after a while. The performances were fine, and although the writing was a little clunky at times, there were also several fine speeches, most notably Amanda's description of her time in Bosnia. It may not be a masterpiece, but this deserves better audiences, and I hope they get them.
The Cottesloe was in an unfamiliar arrangement for this play, an interesting cross between a standard domestic drama and an airing of viewpoints on the Israel/Palestinian conflict. Speaking as someone with no vested interest, and with a less than perfect knowledge of the recent history of this subject matter, I can only comment that as far as I could tell, the views expressed seemed to be balanced overall, with no 'side' coming out on top, although individual characters naturally took up strong positions to allow the debate to take place. I certainly felt I knew a bit more about the subject than when I arrived, though that wouldn't be difficult.
The set was a living/dining room, placed diagonally across the Cottesloe space. We were on the dining table side of the room; to our right was the exit to the kitchen, and round from that were the sofas at right angles to each other, with coffee table. Opposite us was the door from the hall, and along the left side as we looked at it was a long sideboard with many family pictures in frames. The seating rose up steeply on all sides, so naturally there was nothing on the 'walls', and even the front row was looking down on the action.
The Rosenberg family are kosher caterers in the Edgware area. David, the father, and Lesley, the mother, have been working hard to rebuild their business after an unfortunate death at an event they catered. Although it wasn't caused by food poisoning, the mud stuck, and now the business is on the verge of collapse. Their son, Jonny, appears to be a waster, sponging off his parents but having grand schemes to get rich quick – internet gambling is the current wheeze – and with no intention of going into the family business. Their daughter, Ruth, is an over-achiever, a high-flying lawyer who's working on a UN inquiry into possible war crimes in Gaza. She's come back to the family home for the funeral of the other son, Danny, who was a pilot out in Israel, and died in action there. There's a lot of scope for discussion just among these four people, but we also get a young rabbi, Simon, who was once Ruth's boyfriend, the chairman of the synagogue, Saul, whom David hopes will book his firm to do the catering for his (Saul's) daughter's wedding, and Stephen, the chairman of the inquiry that Ruth is working for, who drops by to leave her some entirely relevant papers on the evening of the funeral. A bit far-fetched, but that's drama for you.
There was plenty of humour throughout the play, and although there were serious moments too, it never got preachy or too heavy. The antagonism felt in the Jewish community towards Ruth for her part in the UN investigation into potential war crimes leads Simon, and later Saul, to suggest that she stay away from the service, while David is suffering from unacknowledged guilt because he put pressure on Danny to stay in the danger zone, even though Danny himself wanted to come home. All these factors are woven together very skilfully, and the production was a delight to watch, with excellent performances all round.


text:
//! A group of attributes that can be attached to Rust code in order
//! to generate a clippy lint detecting said code automatically.

use clippy_utils::get_attr;
use rustc_ast::ast::{LitFloatType, LitKind};
use rustc_ast::walk_list;
use rustc_data_structures::fx::FxHashMap;
use rustc_hir as hir;
use rustc_hir::intravisit::{NestedVisitorMap, Visitor};
use rustc_hir::{Block, Expr, ExprKind, Pat, PatKind, QPath, Stmt, StmtKind, TyKind};
use rustc_lint::{LateContext, LateLintPass, LintContext};
use rustc_middle::hir::map::Map;
use rustc_session::{declare_lint_pass, declare_tool_lint};

declare_clippy_lint! {
    /// ### What it does
    /// Generates clippy code that detects the offending pattern
    ///
    /// ### Example
    /// ```rust,ignore
    /// // ./tests/ui/my_lint.rs
    /// fn foo() {
    ///     // detect the following pattern
    ///     #[clippy::author]
    ///     if x == 42 {
    ///         // but ignore everything from here on
    ///         #![clippy::author = "ignore"]
    ///     }
    ///     ()
    /// }
    /// ```
    ///
    /// Running `TESTNAME=ui/my_lint cargo uitest` will produce
    /// a `./tests/ui/new_lint.stdout` file with the generated code:
    ///
    /// ```rust,ignore
    /// // ./tests/ui/new_lint.stdout
    /// if_chain! {
    ///     if let ExprKind::If(ref cond, ref then, None) = item.kind,
    ///     if let ExprKind::Binary(BinOp::Eq, ref left, ref right) = cond.kind,
    ///     if let ExprKind::Path(ref path) = left.kind,
    ///     if let ExprKind::Lit(ref lit) = right.kind,
    ///     if let LitKind::Int(42, _) = lit.node,
    ///     then {
    ///         // report your lint here
    ///     }
    /// }
    /// ```
    pub LINT_AUTHOR,
    internal_warn,
    "helper for writing lints"
}

declare_lint_pass!(Author => [LINT_AUTHOR]);

fn prelude() {
    println!("if_chain! {{");
}

fn done() {
    println!("    then {{");
    println!("        // report your lint here");
    println!("    }}");
    println!("}}");
}

impl<'tcx> LateLintPass<'tcx> for Author {
    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
        if !has_attr(cx, item.hir_id()) {
            return;
        }
        prelude();
        PrintVisitor::new("item").visit_item(item);
        done();
    }

    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
        if !has_attr(cx, item.hir_id()) {
            return;
        }
        prelude();
        PrintVisitor::new("item").visit_impl_item(item);
        done();
    }

    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
        if !has_attr(cx, item.hir_id()) {
            return;
        }
        prelude();
        PrintVisitor::new("item").visit_trait_item(item);
        done();
    }

    fn check_variant(&mut self, cx: &LateContext<'tcx>, var: &'tcx hir::Variant<'_>) {
        if !has_attr(cx, var.id) {
            return;
        }
        prelude();
        let parent_hir_id = cx.tcx.hir().get_parent_node(var.id);
        PrintVisitor::new("var").visit_variant(var, &hir::Generics::empty(), parent_hir_id);
        done();
    }

    fn check_field_def(&mut self, cx: &LateContext<'tcx>, field: &'tcx hir::FieldDef<'_>) {
        if !has_attr(cx, field.hir_id) {
            return;
        }
        prelude();
        PrintVisitor::new("field").visit_field_def(field);
        done();
    }

    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
        if !has_attr(cx, expr.hir_id) {
            return;
        }
        prelude();
        PrintVisitor::new("expr").visit_expr(expr);
        done();
    }

    fn check_arm(&mut self, cx: &LateContext<'tcx>, arm: &'tcx hir::Arm<'_>) {
        if !has_attr(cx, arm.hir_id) {
            return;
        }
        prelude();
        PrintVisitor::new("arm").visit_arm(arm);
        done();
    }

    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) {
        if !has_attr(cx, stmt.hir_id) {
            return;
        }
        match stmt.kind {
            StmtKind::Expr(e) | StmtKind::Semi(e) if has_attr(cx, e.hir_id) => return,
            _ => {},
        }
        prelude();
        PrintVisitor::new("stmt").visit_stmt(stmt);
        done();
    }

    fn check_foreign_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ForeignItem<'_>) {
        if !has_attr(cx, item.hir_id()) {
            return;
        }
        prelude();
        PrintVisitor::new("item").visit_foreign_item(item);
        done();
    }
}

impl PrintVisitor {
    #[must_use]
    fn new(s: &'static str) -> Self {
        Self {
            ids: FxHashMap::default(),
            current: s.to_owned(),
        }
    }

    fn next(&mut self, s: &'static str) -> String {
        use std::collections::hash_map::Entry::{Occupied, Vacant};
        match self.ids.entry(s) {
            // already there: start numbering from `1`
            Occupied(mut occ) => {
                let val = occ.get_mut();
                *val += 1;
                format!("{}{}", s, *val)
            },
            // not there: insert and return name as given
            Vacant(vac) => {
                vac.insert(0);
                s.to_owned()
            },
        }
    }

    fn print_qpath(&mut self, path: &QPath<'_>) {
        if let QPath::LangItem(lang_item, _) = *path {
            println!(
                "    if matches!({}, QPath::LangItem(LangItem::{:?}, _));",
                self.current, lang_item,
            );
        } else {
            print!("    if match_qpath({}, &[", self.current);
            print_path(path, &mut true);
            println!("]);");
        }
    }
}

struct PrintVisitor {
    /// Fields are the current index that needs to be appended to pattern
    /// binding names
    ids: FxHashMap<&'static str, usize>,
    /// the name that needs to be destructured
    current: String,
}

impl<'tcx> Visitor<'tcx> for PrintVisitor {
    type Map = Map<'tcx>;

    #[allow(clippy::too_many_lines)]
    fn visit_expr(&mut self, expr: &Expr<'_>) {
        print!("    if let ExprKind::");
        let current = format!("{}.kind", self.current);
        match expr.kind {
            ExprKind::Let(pat, expr, _) => {
                let let_pat = self.next("pat");
                let let_expr = self.next("expr");
                println!("    Let(ref {}, ref {}, _) = {};", let_pat, let_expr, current);
                self.current = let_expr;
                self.visit_expr(expr);
                self.current = let_pat;
                self.visit_pat(pat);
            },
            ExprKind::Box(inner) => {
                let inner_pat = self.next("inner");
                println!("Box(ref {}) = {};", inner_pat, current);
                self.current = inner_pat;
                self.visit_expr(inner);
            },
            ExprKind::Array(elements) => {
                let elements_pat = self.next("elements");
                println!("Array(ref {}) = {};", elements_pat, current);
                println!("    if {}.len() == {};", elements_pat, elements.len());
                for (i, element) in elements.iter().enumerate() {
                    self.current = format!("{}[{}]", elements_pat, i);
                    self.visit_expr(element);
                }
            },
            ExprKind::Call(func, args) => {
                let func_pat = self.next("func");
                let args_pat = self.next("args");
                println!("Call(ref {}, ref {}) = {};", func_pat, args_pat, current);
                self.current = func_pat;
                self.visit_expr(func);
                println!("    if {}.len() == {};", args_pat, args.len());
                for (i, arg) in args.iter().enumerate() {
                    self.current = format!("{}[{}]", args_pat, i);
                    self.visit_expr(arg);
                }
            },
            ExprKind::MethodCall(_method_name, ref _generics, _args, ref _fn_span) => {
                println!(
                    "MethodCall(ref method_name, ref generics, ref args, ref fn_span) = {};",
                    current
                );
                println!("    // unimplemented: `ExprKind::MethodCall` is not further destructured at the moment");
            },
            ExprKind::Tup(elements) => {
                let elements_pat = self.next("elements");
                println!("Tup(ref {}) = {};", elements_pat, current);
                println!("    if {}.len() == {};", elements_pat, elements.len());
                for (i, element) in elements.iter().enumerate() {
                    self.current = format!("{}[{}]", elements_pat, i);
                    self.visit_expr(element);
                }
            },
            ExprKind::Binary(ref op, left, right) => {
                let op_pat = self.next("op");
                let left_pat = self.next("left");
                let right_pat = self.next("right");
                println!(
                    "Binary(ref {}, ref {}, ref {}) = {};",
                    op_pat, left_pat, right_pat, current
                );
                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
                self.current = left_pat;
                self.visit_expr(left);
                self.current = right_pat;
                self.visit_expr(right);
            },
            ExprKind::Unary(ref op, inner) => {
                let inner_pat = self.next("inner");
                println!("Unary(UnOp::{:?}, ref {}) = {};", op, inner_pat, current);
                self.current = inner_pat;
                self.visit_expr(inner);
            },
            ExprKind::Lit(ref lit) => {
                let lit_pat = self.next("lit");
                println!("Lit(ref {}) = {};", lit_pat, current);
                match lit.node {
                    LitKind::Bool(val) => println!("    if let LitKind::Bool({:?}) = {}.node;", val, lit_pat),
                    LitKind::Char(c) => println!("    if let LitKind::Char({:?}) = {}.node;", c, lit_pat),
                    LitKind::Err(val) => println!("    if let LitKind::Err({}) = {}.node;", val, lit_pat),
                    LitKind::Byte(b) => println!("    if let LitKind::Byte({}) = {}.node;", b, lit_pat),
                    // FIXME: also check int type
                    LitKind::Int(i, _) => println!("    if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
                    LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
                        "    if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
                        lit_pat
                    ),
                    LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
                        "    if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
                        lit_pat
                    ),
                    LitKind::ByteStr(ref vec) => {
                        let vec_pat = self.next("vec");
                        println!("    if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
                        println!("    if let [{:?}] = **{};", vec, vec_pat);
                    },
                    LitKind::Str(ref text, _) => {
                        let str_pat = self.next("s");
                        println!("    if let LitKind::Str(ref {}, _) = {}.node;", str_pat, lit_pat);
                        println!("    if {}.as_str() == {:?}", str_pat, &*text.as_str());
                    },
                }
            },
            ExprKind::Cast(expr, ty) => {
                let cast_pat = self.next("expr");
                let cast_ty = self.next("cast_ty");
                let qp_label = self.next("qp");

                println!("Cast(ref {}, ref {}) = {};", cast_pat, cast_ty, current);
                if let TyKind::Path(ref qp) = ty.kind {
                    println!("    if let TyKind::Path(ref {}) = {}.kind;", qp_label, cast_ty);
                    self.current = qp_label;
                    self.print_qpath(qp);
                }
                self.current = cast_pat;
                self.visit_expr(expr);
            },
            ExprKind::Type(expr, _ty) => {
                let cast_pat = self.next("expr");
                println!("Type(ref {}, _) = {};", cast_pat, current);
                self.current = cast_pat;
                self.visit_expr(expr);
            },
            ExprKind::Loop(body, _, des, _) => {
                let body_pat = self.next("body");
                let label_pat = self.next("label");
                println!(
                    "Loop(ref {}, ref {}, LoopSource::{:?}) = {};",
                    body_pat, label_pat, des, current
                );
                self.current = body_pat;
                self.visit_block(body);
            },
            ExprKind::If(cond, then, ref opt_else) => {
                let cond_pat = self.next("cond");
                let then_pat = self.next("then");
                if let Some(else_) = *opt_else {
                    let else_pat = self.next("else_");
                    println!(
                        "If(ref {}, ref {}, Some(ref {})) = {};",
                        cond_pat, then_pat, else_pat, current
                    );
                    self.current = else_pat;
                    self.visit_expr(else_);
                } else {
                    println!("If(ref {}, ref {}, None) = {};", cond_pat, then_pat, current);
                }
                self.current = cond_pat;
                self.visit_expr(cond);
                self.current = then_pat;
                self.visit_expr(then);
            },
            ExprKind::Match(expr, arms, des) => {
                let expr_pat = self.next("expr");
                let arms_pat = self.next("arms");
                println!(
                    "Match(ref {}, ref {}, MatchSource::{:?}) = {};",
                    expr_pat, arms_pat, des, current
                );
                self.current = expr_pat;
                self.visit_expr(expr);
                println!("    if {}.len() == {};", arms_pat, arms.len());
                for (i, arm) in arms.iter().enumerate() {
                    self.current = format!("{}[{}].body", arms_pat, i);
                    self.visit_expr(arm.body);
                    if let Some(ref guard) = arm.guard {
                        let guard_pat = self.next("guard");
                        println!("    if let Some(ref {}) = {}[{}].guard;", guard_pat, arms_pat, i);
                        match guard {
                            hir::Guard::If(if_expr) => {
                                let if_expr_pat = self.next("expr");
                                println!("    if let Guard::If(ref {}) = {};", if_expr_pat, guard_pat);
                                self.current = if_expr_pat;
                                self.visit_expr(if_expr);
                            },
                            hir::Guard::IfLet(if_let_pat, if_let_expr) => {
                                let if_let_pat_pat = self.next("pat");
                                let if_let_expr_pat = self.next("expr");
                                println!(
                                    "    if let Guard::IfLet(ref {}, ref {}) = {};",
                                    if_let_pat_pat, if_let_expr_pat, guard_pat
                                );
                                self.current = if_let_expr_pat;
                                self.visit_expr(if_let_expr);
                                self.current = if_let_pat_pat;
                                self.visit_pat(if_let_pat);
                            },
                        }
                    }
                    self.current = format!("{}[{}].pat", arms_pat, i);
                    self.visit_pat(arm.pat);
                }
            },
            ExprKind::Closure(ref _capture_clause, _func, _, _, _) => {
                println!("Closure(ref capture_clause, ref func, _, _, _) = {};", current);
                println!("    // unimplemented: `ExprKind::Closure` is not further destructured at the moment");
            },
            ExprKind::Yield(sub, _) => {
                let sub_pat = self.next("sub");
                println!("Yield(ref sub) = {};", current);
                self.current = sub_pat;
                self.visit_expr(sub);
            },
            ExprKind::Block(block, _) => {
                let block_pat = self.next("block");
                println!("Block(ref {}) = {};", block_pat, current);
                self.current = block_pat;
                self.visit_block(block);
            },
            ExprKind::Assign(target, value, _) => {
                let target_pat = self.next("target");
                let value_pat = self.next("value");
                println!(
                    "Assign(ref {}, ref {}, ref _span) = {};",
                    target_pat, value_pat, current
                );
                self.current = target_pat;
                self.visit_expr(target);
                self.current = value_pat;
                self.visit_expr(value);
            },
            ExprKind::AssignOp(ref op, target, value) => {
                let op_pat = self.next("op");
                let target_pat = self.next("target");
                let value_pat = self.next("value");
                println!(
                    "AssignOp(ref {}, ref {}, ref {}) = {};",
                    op_pat, target_pat, value_pat, current
                );
                println!("    if BinOpKind::{:?} == {}.node;", op.node, op_pat);
                self.current = target_pat;
                self.visit_expr(target);
                self.current = value_pat;
                self.visit_expr(value);
            },
            ExprKind::Field(object, ref field_ident) => {
                let obj_pat = self.next("object");
                let field_name_pat = self.next("field_name");
                println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
                println!("    if {}.as_str() == {:?}", field_name_pat, field_ident.as_str());
                self.current = obj_pat;
                self.visit_expr(object);
            },
            ExprKind::Index(object, index) => {
                let object_pat = self.next("object");
                let index_pat = self.next("index");
                println!("Index(ref {}, ref {}) = {};", object_pat, index_pat, current);
                self.current = object_pat;
                self.visit_expr(object);
                self.current = index_pat;
                self.visit_expr(index);
            },
            ExprKind::Path(ref path) => {
                let path_pat = self.next("path");
                println!("Path(ref {}) = {};", path_pat, current);
                self.current = path_pat;
                self.print_qpath(path);
            },
            ExprKind::AddrOf(kind, mutability, inner) => {
                let inner_pat = self.next("inner");
                println!(
                    "AddrOf(BorrowKind::{:?}, Mutability::{:?}, ref {}) = {};",
                    kind, mutability, inner_pat, current
                );
                self.current = inner_pat;
                self.visit_expr(inner);
            },
            ExprKind::Break(ref _destination, ref opt_value) => {
                let destination_pat = self.next("destination");
                if let Some(value) = *opt_value {
                    let value_pat = self.next("value");
                    println!("Break(ref {}, Some(ref {})) = {};", destination_pat, value_pat, current);
                    self.current = value_pat;
                    self.visit_expr(value);
                } else {
                    println!("Break(ref {}, None) = {};", destination_pat, current);
                }
                // FIXME: implement label printing
            },
            ExprKind::Continue(ref _destination) => {
                let destination_pat = self.next("destination");
                println!("Again(ref {}) = {};", destination_pat, current);
                // FIXME: implement label printing
            },
            ExprKind::Ret(ref opt_value) => {
                if let Some(value) = *opt_value {
                    let value_pat = self.next("value");
                    println!("Ret(Some(ref {})) = {};", value_pat, current);
                    self.current = value_pat;
                    self.visit_expr(value);
                } else {
                    println!("Ret(None) = {};", current);
                }
            },
            ExprKind::InlineAsm(_) => {
                println!("InlineAsm(_) = {};", current);
                println!("    // unimplemented: `ExprKind::InlineAsm` is not further destructured at the moment");
            },
            ExprKind::LlvmInlineAsm(_) => {
                println!("LlvmInlineAsm(_) = {};", current);
                println!("    // unimplemented: `ExprKind::LlvmInlineAsm` is not further destructured at the moment");
            },
            ExprKind::Struct(path, fields, ref opt_base) => {
                let path_pat = self.next("path");
                let fields_pat = self.next("fields");
                if let Some(base) = *opt_base {
                    let base_pat = self.next("base");
                    println!(
                        "Struct(ref {}, ref {}, Some(ref {})) = {};",
                        path_pat, fields_pat, base_pat, current
                    );
                    self.current = base_pat;
                    self.visit_expr(base);
                } else {
                    println!("Struct(ref {}, ref {}, None) = {};", path_pat, fields_pat, current);
                }
                self.current = path_pat;
                self.print_qpath(path);
                println!("    if {}.len() == {};", fields_pat, fields.len());
                println!("    // unimplemented: field checks");
            },
            ExprKind::ConstBlock(_) => {
                let value_pat = self.next("value");
                println!("Const({})", value_pat);
                self.current = value_pat;
            },
            // FIXME: compute length (needs type info)
            ExprKind::Repeat(value, _) => {
                let value_pat = self.next("value");
                println!("Repeat(ref {}, _) = {};", value_pat, current);
                println!("// unimplemented: repeat count check");
                self.current = value_pat;
                self.visit_expr(value);
            },
            ExprKind::Err => {
                println!("Err = {}", current);
            },
            ExprKind::DropTemps(expr) => {
                let expr_pat = self.next("expr");
                println!("DropTemps(ref {}) = {};", expr_pat, current);
                self.current = expr_pat;
                self.visit_expr(expr);
            },
        }
    }

    fn visit_block(&mut self, block: &Block<'_>) {
        println!("    if {}.stmts.len() == {};", self.current, block.stmts.len());
        let block_name = self.current.clone();
        for (i, stmt) in block.stmts.iter().enumerate() {
            self.current = format!("{}.stmts[{}]", block_name, i);
            self.visit_stmt(stmt);
        }
        if let Some(expr) = block.expr {
            self.current = self.next("trailing_expr");
            println!("    if let Some({}) = &{}.expr;", self.current, block_name);
            self.visit_expr(expr);
        } else {
            println!("    if {}.expr.is_none();", block_name);
        }
    }

    #[allow(clippy::too_many_lines)]
    fn visit_pat(&mut self, pat: &Pat<'_>) {
        print!("    if let PatKind::");
        let current = format!("{}.kind", self.current);
        match pat.kind {
            PatKind::Wild => println!("Wild = {};", current),
            PatKind::Binding(anno, .., ident, ref sub) => {
                let anno_pat = &format!("BindingAnnotation::{:?}", anno);
                let name_pat = self.next("name");
                if let Some(sub) = *sub {
                    let sub_pat = self.next("sub");
                    println!(
                        "Binding({}, _, {}, Some(ref {})) = {};",
                        anno_pat, name_pat, sub_pat, current
                    );
                    self.current = sub_pat;
                    self.visit_pat(sub);
                } else {
                    println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
                }
                println!("    if {}.as_str() == \"{}\";", name_pat, ident.as_str());
            },
            PatKind::Struct(ref path, fields, ignore) => {
                let path_pat = self.next("path");
                let fields_pat = self.next("fields");
                println!(
                    "Struct(ref {}, ref {}, {}) = {};",
                    path_pat, fields_pat, ignore, current
                );
                self.current = path_pat;
                self.print_qpath(path);
                println!("    if {}.len() == {};", fields_pat, fields.len());
                println!("    // unimplemented: field checks");
            },
            PatKind::Or(fields) => {
                let fields_pat = self.next("fields");
                println!("Or(ref {}) = {};", fields_pat, current);
                println!("    if {}.len() == {};", fields_pat, fields.len());
                println!("    // unimplemented: field checks");
            },
            PatKind::TupleStruct(ref path, fields, skip_pos) => {
                let path_pat = self.next("path");
                let fields_pat = self.next("fields");
                println!(
                    "TupleStruct(ref {}, ref {}, {:?}) = {};",
                    path_pat, fields_pat, skip_pos, current
                );
                self.current = path_pat;
                self.print_qpath(path);
                println!("    if {}.len() == {};", fields_pat, fields.len());
                println!("    // unimplemented: field checks");
            },
            PatKind::Path(ref path) => {
                let path_pat = self.next("path");
                println!("Path(ref {}) = {};", path_pat, current);
                self.current = path_pat;
                self.print_qpath(path);
            },
            PatKind::Tuple(fields, skip_pos) => {
                let fields_pat = self.next("fields");
                println!("Tuple(ref {}, {:?}) = {};", fields_pat, skip_pos, current);
                println!("    if {}.len() == {};", fields_pat, fields.len());
                println!("    // unimplemented: field checks");
            },
            PatKind::Box(pat) => {
                let pat_pat = self.next("pat");
                println!("Box(ref {}) = {};", pat_pat, current);
                self.current = pat_pat;
                self.visit_pat(pat);
            },
            PatKind::Ref(pat, muta) => {
                let pat_pat = self.next("pat");
                println!("Ref(ref {}, Mutability::{:?}) = {};", pat_pat, muta, current);
                self.current = pat_pat;
                self.visit_pat(pat);
            },
            PatKind::Lit(lit_expr) => {
                let lit_expr_pat = self.next("lit_expr");
                println!("Lit(ref {}) = {}", lit_expr_pat, current);
                self.current = lit_expr_pat;
                self.visit_expr(lit_expr);
            },
            PatKind::Range(ref start, ref end, end_kind) => {
                let start_pat = self.next("start");
                let end_pat = self.next("end");
                println!(
                    "Range(ref {}, ref {}, RangeEnd::{:?}) = {};",
                    start_pat, end_pat, end_kind, current
                );
                self.current = start_pat;
                walk_list!(self, visit_expr, start);
                self.current = end_pat;
                walk_list!(self, visit_expr, end);
            },
            PatKind::Slice(start, ref middle, end) => {
                let start_pat = self.next("start");
                let end_pat = self.next("end");
                if let Some(middle) = middle {
                    let middle_pat = self.next("middle");
                    println!(
                        "Slice(ref {}, Some(ref {}), ref {}) = {};",
                        start_pat, middle_pat, end_pat, current
                    );
                    self.current = middle_pat;
                    self.visit_pat(middle);
                } else {
                    println!("Slice(ref {}, None, ref {}) = {};", start_pat, end_pat, current);
                }
                println!("    if {}.len() == {};", start_pat, start.len());
                for (i, pat) in start.iter().enumerate() {
                    self.current = format!("{}[{}]", start_pat, i);
                    self.visit_pat(pat);
                }
                println!("    if {}.len() == {};", end_pat, end.len());
                for (i, pat) in end.iter().enumerate() {
                    self.current = format!("{}[{}]", end_pat, i);
                    self.visit_pat(pat);
                }
            },
        }
    }

    fn visit_stmt(&mut self, s: &Stmt<'_>) {
        print!("    if let StmtKind::");
        let current = format!("{}.kind", self.current);
        match s.kind {
            // A local (let) binding:
            StmtKind::Local(local) => {
                let local_pat = self.next("local");
                println!("Local(ref {}) = {};", local_pat, current);
                if let Some(init) = local.init {
                    let init_pat = self.next("init");
                    println!("    if let Some(ref {}) = {}.init;", init_pat, local_pat);
                    self.current = init_pat;
                    self.visit_expr(init);
                }
                self.current = format!("{}.pat", local_pat);
                self.visit_pat(local.pat);
            },
            // An item binding:
            StmtKind::Item(_) => {
                println!("Item(item_id) = {};", current);
            },

            // Expr without trailing semi-colon (must have unit type):
            StmtKind::Expr(e) => {
                let e_pat = self.next("e");
                println!("Expr(ref {}, _) = {}", e_pat, current);
                self.current = e_pat;
                self.visit_expr(e);
            },

            // Expr with trailing semi-colon (may have any type):
            StmtKind::Semi(e) => {
                let e_pat = self.next("e");
                println!("Semi(ref {}, _) = {}", e_pat, current);
                self.current = e_pat;
                self.visit_expr(e);
            },
        }
    }

    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
        NestedVisitorMap::None
    }
}

fn has_attr(cx: &LateContext<'_>, hir_id: hir::HirId) -> bool {
    let attrs = cx.tcx.hir().attrs(hir_id);
    get_attr(cx.sess(), attrs, "author").count() > 0
}

fn print_path(path: &QPath<'_>, first: &mut bool) {
    match *path {
        QPath::Resolved(_, path) => {
            for segment in path.segments {
                if *first {
                    *first = false;
                } else {
                    print!(", ");
                }
                print!("{:?}", segment.ident.as_str());
            }
        },
        QPath::TypeRelative(ty, segment) => match ty.kind {
            hir::TyKind::Path(ref inner_path) => {
                print_path(inner_path, first);
                if *first {
                    *first = false;
                } else {
                    print!(", ");
                }
                print!("{:?}", segment.ident.as_str());
            },
            ref other => print!("/* unimplemented: {:?}*/", other),
        },
        QPath::LangItem(..) => panic!("print_path: called for lang item qpath"),
    }
}

redpajama_set_name: RedPajamaGithub


text:
Q: couchbase lite .net and typed objects I'm trying to use couchbase lite in an app but I can't get the hang of creating a document from an object.
All I see is a PutProperties method expecting a dictionary, but I don't have dictionaries. I have normal typed objects.
Is there any way to get couchbase lite to accept such an object? Failing that, is there nay way to get couchbase lite to accept a string and interpret this as a json document? Then I could use newtonsoft.json to serialize the objects and pass them in.
Lots of Greetings!

A: At the moment these features are roughly planned (the first one is more talked about than the second, but the second has been mentioned).  Right now the focus on .NET is feature parity with the other platforms (Objective-C and Android / Java) since it was the last out of the gate.  In 2.0 we would like to see this feature realized.  The current version in development is 1.2 and it's possible that the release after that will be 2.0, but I don't think that is confirmed yet.  Keep in mind that this answer should not be taken as fact as it is discussing future development and is subject to change for any number of reasons (not the least of which is demand for a certain feature).  In the meantime, if you would like to see this feature the best thing to do would be to file an issue on GitHub about it.

redpajama_set_name: RedPajamaStackExchange


This article introduces Extension's Vital Connections On Air podcasts focused on Minnesota's workforce challenges. We hope you will listen to and subscribe to all Vital Connections On Air podcasts.
When Extension educator Christy Kallevig decided to focus a series of Vital Connections On Air podcasts on Minnesota's workforce issues, she didn't realize covering the issue would take six months — and then some.
"The onion layers just kept peeling off," she says. "Businesses can't fill jobs without able workers. Educators can't prepare workers to take jobs when they don't know how technology will change those jobs in five years. Workers can't take jobs if basics like child care and housing aren't available. And in a market where workers can be choosy, workers won't take jobs in communities or businesses where their needs and wants aren't met."
After hosting five podcast conversations on the issue, and with six more are on the way, Kallevig empathizes with community and regional leaders who are grappling with local workforce challenges. "What part of the problem do you attack first? Where do you invest time and money? I hope that information and support from Extension and other organizations can help them navigate this complex issue."
"Imagine if Minnesota became the state that worked together and did a great job resolving our workforce challenges. Wouldn't that create exciting things for our future economy?"
In an introduction to workforce issues, state economist and Extension colleague Laura Kalambokidis describes one "upside" that the workforce shortage could bring to Minnesota. She hopes that this can become an opportunity to bring people on the margins of the workforce into the mainstream. "At this point, we can't afford to leave anyone on the sidelines," she says. "Everyone needs to be participating in Minnesota's labor force."
"Smart businesses are getting creative," she says. She has seen that businesses are thinking about how older Minnesotans can work from home or even, in the case of older Minnesotans, from the boat. They are rethinking the mandatory qualifications that can come between good workers and good jobs. Agencies and advocates who know how to accommodate disabled workers or recruit from underemployed communities are making matches. Businesses are working with community leaders to create towns that are attractive to potential workers and welcome new residents.
"Imagine," says Kalambokidis, "if Minnesota became the state that worked together and did a great job resolving our workforce challenges. Wouldn't that create exciting things for our future economy?"
Bob Kill of Enterprise Minnesota, a consulting organization for Minnesota's manufacturing sector, joined Kallevig to describe the issue from a manufacturer's perspective. Enterprise Minnesota's annual survey of manufacturers spotted a workforce problem before media reported on it.
"When I see articles saying we have a workforce problem, I kind of laugh because we've known this. We've been admiring this problem for years. What I see now — communities, high schools, technical colleges, economic development, and local chambers are rallying."
He gives examples where businesses are working with communities to address the issue. An individual in Redwood Falls, Minnesota, for example, donated a million dollars to the school system to help schools address workforce needs. And when Hutchinson, Minnesota built a new high school, manufacturers committed more than $1.6 million to fund curriculum and facilities that help students understand what a career in modern manufacturing is really like.
Kill appreciates organizations like the Initiative Foundations in Greater Minnesota for valuing manufacturers, especially in rural areas of the state where, as past surveys have shown, some of the biggest problems exist.
And he shares some of Kalambokis' optimism about Minnesota's ability to solve these problems. "There are issues, but they are rising to the top better than they have for a long time," he says. "We are more concerned about the vitality of the communities we're talking about. We need a vibrant Greater Minnesota economy."
As the baby boomer generation leaves the work force, many women boomers are leaving the child care profession. That, in addition to difficult business conditions, has caused child care businesses to close and created a crisis for families looking for day care. That issue, too, is worse in Greater Minnesota where populations are sparse.
"A lot of people are thinking we need to look at child care differently. This isn't just a personal family issue. Communities are starting to come together … to find solutions."
Kallevig invited Marnie Werner, director of research at the Center for Rural Policy, to talk about Minnesota's child care issues. Werner shared insights from research she led on the issue, which was published by the Center in 2016.
"A lot of people are thinking we need to look at child care differently. This isn't just a personal family issue. Communities are starting to come together … to find solutions," says Werner.
For example, one small city waived licensing fees for anyone who wanted to open a day care, and city leaders in Clinton, Minnesota worked with a local church congregation to gift their closed building to a child care entrepreneur. "It's those kind of community solutions that will be the most successful," she said.
Werner is optimistic about the role education can play in stimulating community action. "I think once people understand the economic forces at work in day care operations — what makes it difficult to operate a day care in a sparsely populated area — they can start looking for solutions … Once you understand the economic forces at work, you can deal with what you know and work with what you have."
Our 2018 series on Minnesota's workforce covered the gamut of workforce issues. Listen to the podcasts.
Many communities in Minnesota face workforce housing issues. Listen as we talk about Glenwood's housing study and how understanding existing workers' needs helps them plan for the future.
Minnesota's workforce is changing. Our workers are aging and new employees are often newcomers to our country. Listen as we discuss the impact of immigrants in our labor market.
Minnesota's business community is on the front line of addressing workforce issues. Listen as we explore what is happening and how companies are supporting immigrants and immigration policy.
Business owners are a critical part of rural Minnesota's workforce and local leadership. But selling a small business is not the same as selling a house. Listen as we discuss how business owners and buyers can prepare for this transition and how communities can help.
How can we create a vibrant Minnesota workforce? Listen to a variety of speakers share insight on workforce issues and how to prepare and help those affected.
How do we address Minnesota's workforce issues? Listen to speakers from the University of Minnesota and Extension share their insight on the labor market.
Follow us on Facebook and Twitter or subscribe via Apple Podcasts to be notified of new podcasts.


text:
P/T - Instruction & Online Learning Librarian, Ade...
Librarian of Practice IV, Rutgers U (NJ)
Research Support/Electronic Rscs Librarian, Columb...
Digital Asset Manager, UNICEF (NY)
Data Curator II, Center for Comms Research (NJ)
Records & Archives Mgr, Ford Foundation (NY)
F/T - HBO Knowledge Mgmt Specialist, Time Warner (...
Head, Acad Engagement Librarian, Stony Brook U (NY...
Senior Implementation Mgr, Artstor (NH)
P/T - Librarian - Art & Arch Library, NYIT (NY)
Research Associate, Environmental Defense Fund (NY...
F/T - Tech Svcs & Systems Librarian, Bard Grad Ctr...
F/T - Librarian/Asst Univ Archivist for Tech Svcs,...
F/T - Strategic Intelligence Analyst, NY (Donna Co...
F/T - Research Resources Asst, Whitney Mus (NY)
F/T - Asst. Head Librarian, NYU-Anc World Inst (NY...
F/T - Business Librarian, CUNY-Lehman (NY)
Pharmaceutical Research Editor, InfoDesk (telecomm...
F/T - Database Researcher, Marcus & Millichap (NJ)...
Digital Asset Specialist, The Met (NY)
P/T - Digital Initiative Librarian, FIT (NY)
F/T - Emerging Technologies Librarian, FIT (NY)
F/T - News Research Mgr, Associated Press (NY)
P/T - Internet Researcher, PrincetonOne (NY)
Dir, External Content, Knowledge Mgmt, KPMG (NJ)
Knowledge Mgmt Architect, Facebook (NY)
P/T - Librarian, Bryant Library (NY)
Assoc Mgr for Tech Svcs, The Met-Watson Lib (NY)
P/T - Library Associate, EdLab-Columbia U (NY)
F/T - Archives Technician, National Archives (NY)
P/T - Archival Consultant, Whirl-i-Gig (NY)
P/T - Market Researcher, Tri-Lift (NJ)
Knowledge Content Mgr, Audible-Amazon (NY)
F/T - Information Specialist, Ogilvy & Mather (NY)...
F/T - Librarian, Fairview Library (NJ)
F/T - Project Archives Asst, Guggenheim Fdn (NY)
Temp - Project Archivist, Guggenheim Fdn (NY)
F/T - Sup of Engineering Information, Port Authori...
F/T - Digital Svcs Librarian, SVA (NY)
F/T - Research & Instr'l Librarian, Stevens Inst (...
F/T - Archivist, Dedalus Foundation (NY)
Research Assistant, McGarryBowen (NY)
F/T Temp - Librarian, MyLibraryNYC, NYPL (NY)
P/T - Librarian I, N. Castle Library (NY)
Account Mgr, Artstor (NY)
Research Associate, Westwood Partners (NY)
Librarian-Archival Arrangem't & Description, NYU (...
F/T - Asst. Head Librarian, NYU-Anc World Inst (NY)
Assistant Head Librarian, Library of the Institute for the Study of the Ancient World, New York University
New York University seeks a qualified Assistant Head Librarian for the Library of the Institute for the Study of the Ancient World. The Assistant Head Librarian reports to the ISAW Head Librarian.
The Institute for the Study of the Ancient World (ISAW) is a unique center for advanced scholarly research and graduate education, offering the Ph.D. degree through NYU's Graduate School of Arts and Science. It has a wider geographic span than other programs that focus on the ancient world, incorporating not only Europe and the entire Mediterranean basin, but also the Near East, and Central, South, and East Asia. In its research and its teaching of doctoral students, ISAW emphasizes an interdisciplinary approach, one that transcends modern boundaries of nation. It supports scholarship that crosses customary disciplinary boundaries – art history, literature, archaeology, history, geography, geology, economics, and sociology, among others – to create a new intellectual framework for understanding the ancient world, and to train a new generation of scholars steeped in that integrated approach.
The Assistant Head Librarian is responsible for managing day-to-day operations, including:
Library Operations - Coordinate workflow, establish priorities and assign work to ISAW's library staff. Train new staff. Manage special projects by devising appropriate workflows and providing supervision.
Technical Services - Supervise the work of ISAW's cataloging team, a group performing original and complex copy cataloging for all formats in a wide range of subjects and languages using the Ex Libris Aleph client. The cataloging team consists of ISAW staff members and adjuncts from NYU's cataloging department. Facilitate patron resource discovery and access by ensuring the quality of bibliographic and digital databases through compliance with national and local standards such as MARC, AACR2, RDA, LCSH, LCCS, NACO, CONSER, and LC cataloging practices as well as other appropriate cataloging and metadata standards. Provide leadership in the area of metadata management through the selection, creation and application of appropriate metadata frameworks for print and digital records. Participate in the development of standards, policies and procedures to ensure accurate and timely maintenance of print and digital records. Serve as a liaison to Knowledge Access and Resource Management Services (KARMS) and other related departments in the Division of Libraries.
Digital Projects - Serve as the library liaison on ISAW's digital projects team to help develop and coordinate activities linking digital initiatives to library projects. Work closely with the Head Librarian and other members of ISAW's staff to assist in the planning and implementation of The Ancient World Digital Library (AWDL), one of the Digital Initiatives underway at the Institute. AWDL is a joint project shared between ISAW and NYU's Digital Library Technology Services (DLTS) department and the incumbent shares responsibility for envisioning the development of the digital library and its resources.
Collection Development - Sort collections acquired and determine appropriateness for inclusion in the ISAW library or beyond. Maintain inventories for acquired collections, duplicates, and serials. Provide data to the Head Librarian to assist with the task of analyzing the library collection, especially with regard to the curation of on- and off-site collections. Participate in the acquisitions workflow by using the spreadsheet and ticket system to track requests and purchases.
Public Services - Work closely with Head Librarian to provide leadership in the planning, design, and provision of public access services in the ISAW Library, including: producing and revising of library guides; giving individual and group instruction and orientation; serving as a liaison to faculty and graduate students; contributing to the library's public relations efforts; working with faculty members, Visiting Research Scholars, and students on integrating electronic resources into teaching and research; responding to written, telephone, and email reference questions; participating in Division and other institutional committees and activities as appropriate.
ALA-accredited MLS and second subject Master's degree required for tenure;
The ability to use a full range of text and electronic resources in history, archaeology, art history and other areas relevant to ISAW's core research areas.
Working knowledge of the appropriate languages of scholarship;
Familiarity with current trends in technical services;
Excellent interpersonal and communication skills;
Demonstrated ability to work collegially within a small unit that is flexible and responsive to patrons;
Minimum three years professional experience.
Subject area background relevant to the areas of study at ISAW;
Awareness of cross-disciplinary issues in librarianship;
Working knowledge of a non-Western language, with a strong preference for Chinese or Russian.
New York University Libraries:
Libraries at New York University serve the school's 40,000 students and faculty and contain more than 5 million volumes. The Libraries supports NYU's vision to become the first true Global Network University by collaborating and providing services to our 11 global academic centers and "portal campuses" in Abu Dhabi and Shanghai. New York University Libraries is a member of the Association of Research Libraries, the OCLC Research Library Partnership, and the HathiTrust. The Libraries participates in a variety of consortia and collaborates closely with Columbia University Libraries and the New York Public Library through the Manhattan Research Library Consortium. For the NYU Libraries Mission and Strategic Plan go to http://library.nyu.edu/about/Strategic_Plan.pdf
Salary/Benefits: Faculty status, attractive benefits package including five weeks annual vacation. Salary commensurate with experience and background.
To Apply: To ensure consideration, send CV and letter of application, including the name, address, and telephone number of three references to: Enrique Yanez, Director of Human Resources, New York University Libraries, 70 Washington Square South, New York, NY 10012 or via email to jobs@library.nyu.edu. Resumes will be considered until the position is filled.
NYU's Division of Libraries embraces diversity and is committed to attracting qualified candidates who also embrace and value diversity and inclusivity. NYU is an Equal Opportunity/ Affirmative Action Employer.

redpajama_set_name: RedPajamaCommonCrawl


text:
Eurystomella biperforata är en mossdjursart som beskrevs av Gordon, Mawatari och Kajihara 2002. Eurystomella biperforata ingår i släktet Eurystomella och familjen Eurystomellidae.

Artens utbredningsområde är havet kring Nya Zeeland. Inga underarter finns listade i Catalogue of Life.

Källor

Mossdjur
biperforata

redpajama_set_name: RedPajamaWikipedia